Utilisateur:PamputtBot/Creer-pages-conjugaison-espagnol-1.cpp

Les codes présents sur cette page permettent de créer automatiquement les articles concernant les formes conjuguées des verbes espagnols réguliers du premier groupe (se terminant par -ar). Il peut bien sûr être adapté aux autres conjugaisons (toujours pour les verbes réguliers). Plusieurs étapes sont nécessaires

Récupérer une liste de verbes à traiterModifier

J’ai récupéré l’ensemble des verbes présent dans la catégorie Categoría:ES:Verbos regulares sur le Wiktionnaire hispanophone en utilisant quick-intersection sur tools.wmflabs.org. Enregistrer l’ensemble de la liste dans le fichier liste_brute_es1.txt.

Faites de même avec la catégorie Categoría:ES:Verbos regulares con cambio ortográfico qui contient une liste de verbes réguliers mais qi subissent une modification orthographique dans certaines formes conjuguées. Il nous servira plus tard. Enregistrer le contenu dans le fichier liste_chgt_ortho_es.txt.

Identifier les verbes espagnols qui sont présent sur le Wiktionnaire francophoneModifier

On utilise maintenant un script bash, que l'on peut appeler verif_existence.sh, pour vérifier l’existence d’une section en espagnol sur le Wiktionnaire francophone pour chaque verbe contenu dans liste_brute_es1.txt.

#!/bin/bash
nomFichier="liste_brute_es1.txt"

for line in $(cat $nomFichier);
do
    ligneObtenue=`python core/pwb.py core/scripts/listpages.py -get -page:$line | grep "{{langue|es}}"`
    if [ $? -eq 0 ]; then
    #echo $ligneObtenue
        echo $line >> liste_aTraiter_es.txt
    fi
done

Le rendre exécutable en tapant « chmod +x verif_existence.sh » et l’exécuter en tapant « ./verif_existence.sh ». Au bout de quelques minutes (suivant le nombre de verbes à traiter), le fichier liste_aTraiter_es.txt est rempli.

Générer le code xmlModifier

Le programme creer_pages_conjugaison_espagnol_1.cpp va lire le fichier liste_aTraiter_es.txt et va créer un fichier de sortie nommé es_conj.xml qui contient le code à faire ajouter dans les articles. Il crée également un deuxième fichier nommé es_formes_crees.txt et qui contient l’ensemble des formes conjuguées sensées être créées. On utilisera ce fichier par la suite pour vérifier si toutes les pages de formes conjuguées ont été créées (le contenu n’est pas exemple pas ajouté si la page existe préalablement).

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

using namespace std;

string cleDeTri (string mot) {
  string tmp = mot;
  int pos;

  vector < pair < string, string > > equiv;
  equiv.push_back(make_pair(string("á"),string("a")));
  equiv.push_back(make_pair(string("é"),string("e")));
  equiv.push_back(make_pair(string("í"),string("i")));
  equiv.push_back(make_pair(string("ó"),string("o")));

  for(int i=0 ; i<equiv.size() ; i++) {
    pos = mot.find(equiv[i].first);
      if(pos != -1) {
	tmp.replace(pos,2,equiv[i].second); //2 semble éviter d'avoir un caractere juste apres le "a"
      }
  }
  if(tmp == mot) return "";
  return tmp;
}

void corr_car(ofstream &out, string radical, string &mot) {
  int pos;
  pos = mot.rfind("ce");
  if(radical.rfind("c") == radical.length()-1 && // finit par -car
     pos == radical.length()-1) {
    out << mot << endl;
    //c becomes qu before e. 
    // cout << "before: " << mot << endl;
    mot.replace(pos,  2,  "que");
    // cout << "apres: " << mot << endl;
    //  exit(-1);
  }
  pos = mot.rfind("cé");
  if(radical.rfind("c") == radical.length()-1 && // finit par -car
     pos == radical.length()-1) {
    out << mot << endl;
    //c becomes qu before é. 
    // cout << "before: " << mot << endl;
    mot.replace(pos,  3,  "qué"); //3 (au lieu de 2) semble éviter d'avoir un caractere juste apres le "é"
    // cout << "apres: " << mot << endl;
    //  exit(-1);
  }
}

void corr_gar(ofstream &out, string radical, string &mot) {
  int pos;
  pos = mot.rfind("ge");
  if(radical.rfind("g") == radical.length()-1 && // finit par -gar
     pos == radical.length()-1) {
    out << mot << endl;
    //g becomes gu before e. 
    mot.replace(pos,  2,  "gue");
  }
  pos = mot.rfind("gé");
  if(radical.rfind("g") == radical.length()-1 && // finit par -gar
     pos == radical.length()-1) {
    out << mot << endl;
    //c becomes qu before é. 
    mot.replace(pos,  3,  "gué");
  }
}

void corr_uar(ofstream &out, string radical, string &mot, string forme) {
  //ú accentué dans certaines formes

  vector < string > formeAffectee;
  formeAffectee.push_back("ind.p.1s");
  formeAffectee.push_back("ind.p.2s");
  formeAffectee.push_back("ind.p.3s");
  formeAffectee.push_back("ind.p.3p");

  formeAffectee.push_back("sub.p.1s");
  formeAffectee.push_back("sub.p.2s");
  formeAffectee.push_back("sub.p.3s");
  formeAffectee.push_back("sub.p.3p");

  formeAffectee.push_back("imp.p.2s");
  formeAffectee.push_back("imp.p.3s");
  formeAffectee.push_back("imp.p.3p");

  bool trouve;

  if(radical.rfind("u") == radical.length()-1) { // finit par -uar
    trouve = false;
    for(unsigned int i=0 ; i<formeAffectee.size() ; i++) {
      // cout << formeAffectee[i] << " " << forme << endl;
      if(forme == formeAffectee[i]) {
	// cout << "on a trouve" << endl;
	trouve = true;
      }
    }
    if(!trouve) return;
    out << mot << endl;
    cout << "forme : " << forme << ", before: " << mot << endl;
    mot.replace(mot.rfind("u"),  1,  "ú");
    cout << "apres: " << mot << endl;
  }
}

void corr_zar(ofstream &out, string radical, string &mot) {
  int pos;
  pos = mot.rfind("ze");
  if(radical.rfind("z") == radical.length()-1 && // finit par -zar
     pos == radical.length()-1) {
    out << mot << endl;
    //z becomes c before e. 
    mot.replace(pos,  2,  "ce");
  }
  pos = mot.rfind("zé");
  if(radical.rfind("z") == radical.length()-1 && // finit par -zar
     pos == radical.length()-1) {
    out << mot << endl;
    //z becomes c before é. 
    mot.replace(pos,  3,  "cé");
  }
}

int main(int argc, char **argv)
{
  map < string, string > texteDef;
  texteDef["ppr"] = "Participe présent de";
  texteDef["ppa"] = "Participe passé masculin singulier de";

  texteDef["ind.p"]   = "du présent de l’indicatif";
  texteDef["ind.i"]   = "de l’imparfait de l’indicatif";
  texteDef["ind.ps"]  = "du passé simple de l’indicatif";
  texteDef["ind.f"]   = "du futur de l’indicatif";
  texteDef["cond.p."] = "du conditionnel présent";
  texteDef["sub.p"]   = "du présent du subjonctif";
  texteDef["sub.i1"]  = "de l’imparfait (en ''-ra'') du subjonctif";
  texteDef["sub.i2"]  = "de l’imparfait (en ''-se'') du subjonctif";
  texteDef["sub.f"]   = "du futur du subjonctif";
  texteDef["imp.p"]   = "de l’impératif";

  texteDef[".1s"]  = "Première personne du singulier ";
  texteDef[".2s"]  = "Deuxième personne du singulier (''tú'') ";
  texteDef[".2s2"] = "Deuxième personne du singulier (''vos'') ";
  texteDef[".3s"]  = "Troisième personne du singulier ";
  texteDef[".1p"]  = "Première personne du pluriel ";
  texteDef[".2p"]  = "Deuxième personne du pluriel ";
  texteDef[".3p"]  = "Troisième personne du pluriel ";

  vector < string > forme, terminaison, def;
  forme.push_back("ppr");        terminaison.push_back("ando"); def.push_back("Participe présent de");
  forme.push_back("ppa");        terminaison.push_back("ado");  def.push_back("Participe passé masculin singulier de");


  forme.push_back("ind.p.1s");   terminaison.push_back("o");    def.push_back("Première personne du singulier du présent de l’indicatif de");
  forme.push_back("ind.p.2s");   terminaison.push_back("as");   def.push_back("Deuxième personne du singulier (''tú'') du présent de l’indicatif de");
  forme.push_back("ind.p.2s2");  terminaison.push_back("ás");   def.push_back("Deuxième personne du singulier (''vos'') du présent de l’indicatif de");
  forme.push_back("ind.p.3s");   terminaison.push_back("a");    def.push_back("Troisième personne du singulier du présent de l’indicatif de");
  forme.push_back("ind.p.1p");   terminaison.push_back("amos"); def.push_back("Première personne du pluriel du présent de l’indicatif de");
  forme.push_back("ind.p.2p");   terminaison.push_back("áis");  def.push_back("Deuxième personne du pluriel du présent de l’indicatif de");
  forme.push_back("ind.p.3p");   terminaison.push_back("an");   def.push_back("Troisième personne du pluriel du présent de l’indicatif de");           

  forme.push_back("ind.i.1s");   terminaison.push_back("aba");    def.push_back("Première personne du singulier de l’imparfait de l’indicatif de");
  forme.push_back("ind.i.2s");   terminaison.push_back("abas");   def.push_back("Deuxième personne du singulier de l’imparfait de l’indicatif de");
  forme.push_back("ind.i.3s");   terminaison.push_back("aba");    def.push_back("Troisième personne du singulier de l’imparfait de l’indicatif de");
  forme.push_back("ind.i.1p");   terminaison.push_back("ábamos"); def.push_back("Première personne du pluriel de l’imparfait de l’indicatif de");
  forme.push_back("ind.i.2p");   terminaison.push_back("abais");  def.push_back("Deuxième personne du pluriel de l’imparfait de l’indicatif de");
  forme.push_back("ind.i.3p");   terminaison.push_back("aban");   def.push_back("Troisième personne du pluriel de l’imparfait de l’indicatif de");

  forme.push_back("ind.ps.1s");  terminaison.push_back("é");	  def.push_back("Première personne du singulier du passé simple de l’indicatif de");
  forme.push_back("ind.ps.2s");  terminaison.push_back("aste");	  def.push_back("Deuxième personne du singulier du passé simple de l’indicatif de");
  forme.push_back("ind.ps.3s");  terminaison.push_back("ó");	  def.push_back("Troisième personne du singulier du passé simple de l’indicatif de");
  forme.push_back("ind.ps.1p");  terminaison.push_back("amos");	  def.push_back("Première personne du pluriel du passé simple de l’indicatif de");
  forme.push_back("ind.ps.2p");  terminaison.push_back("asteis"); def.push_back("Deuxième personne du pluriel du passé simple de l’indicatif de");
  forme.push_back("ind.ps.3p");  terminaison.push_back("aron");   def.push_back("Troisième personne du pluriel du passé simple de l’indicatif de");

  forme.push_back("ind.f.1s");  terminaison.push_back("aré");	 def.push_back("Première personne du singulier du futur de l’indicatif de");
  forme.push_back("ind.f.2s");  terminaison.push_back("arás");	 def.push_back("Deuxième personne du singulier du futur de l’indicatif de");
  forme.push_back("ind.f.3s");  terminaison.push_back("ará");	 def.push_back("Troisième personne du singulier du futur de l’indicatif de");
  forme.push_back("ind.f.1p");  terminaison.push_back("aremos"); def.push_back("Première personne du pluriel du futur de l’indicatif de");
  forme.push_back("ind.f.2p");  terminaison.push_back("aréis");	 def.push_back("Deuxième personne du pluriel du futur de l’indicatif de");
  forme.push_back("ind.f.3p");  terminaison.push_back("arán");   def.push_back("Troisième personne du pluriel du futur de l’indicatif de");


  forme.push_back("cond.p.1s");  terminaison.push_back("aría");	   def.push_back("Première personne du singulier du conditionnel présent de");
  forme.push_back("cond.p.2s");	 terminaison.push_back("arías");   def.push_back("Deuxième personne du singulier du conditionnel présent de");
  forme.push_back("cond.p.3s");	 terminaison.push_back("aría");	   def.push_back("Troisième personne du singulier du conditionnel présent de"); 
  forme.push_back("cond.p.1p");	 terminaison.push_back("aríamos"); def.push_back("Première personne du pluriel du conditionnel présent de");
  forme.push_back("cond.p.2p");	 terminaison.push_back("aríais");  def.push_back("Deuxième personne du pluriel du conditionnel présent de");
  forme.push_back("cond.p.3p");	 terminaison.push_back("arían");   def.push_back("Troisième personne du pluriel du conditionnel présent de");


  forme.push_back("sub.p.1s");  terminaison.push_back("e");    def.push_back("Première personne du singulier du présent du subjonctif de");
  forme.push_back("sub.p.2s");	terminaison.push_back("es");   def.push_back("Deuxième personne du singulier (''tú'') du présent du subjonctif de");
  forme.push_back("sub.p.2s2");	terminaison.push_back("és");   def.push_back("Deuxième personne du singulier (''vos'') du présent du subjonctif de");
  forme.push_back("sub.p.3s");	terminaison.push_back("e");    def.push_back("Troisième personne du singulier du présent du subjonctif de");
  forme.push_back("sub.p.1p");	terminaison.push_back("emos"); def.push_back("Première personne du pluriel du présent du subjonctif de"); 
  forme.push_back("sub.p.2p");	terminaison.push_back("éis");  def.push_back("Deuxième personne du pluriel du présent du subjonctif de"); 
  forme.push_back("sub.p.3p");	terminaison.push_back("en");   def.push_back("Troisième personne du pluriel du présent du subjonctif de");

  forme.push_back("sub.i1.1s"); terminaison.push_back("ara");    def.push_back("Première personne du singulier de l’imparfait (en -ra) de");    
  forme.push_back("sub.i1.2s");	terminaison.push_back("aras");	 def.push_back("Deuxième personne du singulier de l’imparfait (en -ra) de");    
  forme.push_back("sub.i1.3s");	terminaison.push_back("ara");	 def.push_back("Troisième personne du singulier de l’imparfait (en -ra) de");   
  forme.push_back("sub.i1.1p");	terminaison.push_back("áramos"); def.push_back("Première personne du pluriel de l’imparfait (en -ra) de");      
  forme.push_back("sub.i1.2p");	terminaison.push_back("arais");	 def.push_back("Deuxième personne du pluriel de l’imparfait (en -ra) de");      
  forme.push_back("sub.i1.3p");	terminaison.push_back("aran");	 def.push_back("Troisième personne du pluriel de l’imparfait (en -ra) de");
								                                                                            
  forme.push_back("sub.i2.1s"); terminaison.push_back("ase");	 def.push_back("Première personne du singulier de l’imparfait (en -se) de");
  forme.push_back("sub.i2.2s");	terminaison.push_back("ases");	 def.push_back("Deuxième personne du singulier de l’imparfait (en -se) de");
  forme.push_back("sub.i2.3s");	terminaison.push_back("ase");	 def.push_back("Troisième personne du singulier de l’imparfait (en -se) de");
  forme.push_back("sub.i2.1p");	terminaison.push_back("ásemos"); def.push_back("Première personne du pluriel de l’imparfait (en -se) de");      
  forme.push_back("sub.i2.2p");	terminaison.push_back("aseis");	 def.push_back("Deuxième personne du pluriel de l’imparfait (en -se) de");      
  forme.push_back("sub.i2.3p");	terminaison.push_back("asen");	 def.push_back("Troisième personne du pluriel de l’imparfait (en -se) de");     
								                                                                            
  forme.push_back("sub.f.1s"); terminaison.push_back("are");	 def.push_back("Première personne du singulier du futur du subjonctif de"); 
  forme.push_back("sub.f.2s"); terminaison.push_back("ares");	 def.push_back("Deuxième personne du singulier du futur du subjonctif de"); 
  forme.push_back("sub.f.3s"); terminaison.push_back("are");	 def.push_back("Troisième personne du singulier du futur du subjonctif de");
  forme.push_back("sub.f.1p"); terminaison.push_back("áremos");	 def.push_back("Première personne du pluriel du futur du subjonctif de");   
  forme.push_back("sub.f.2p"); terminaison.push_back("areis");	 def.push_back("Deuxième personne du pluriel du futur du subjonctif de");   
  forme.push_back("sub.f.3p"); terminaison.push_back("aren");	 def.push_back("Troisième personne du pluriel du futur du subjonctif de");  

  forme.push_back("imp.p.2s");  terminaison.push_back("a");      def.push_back("Deuxième personne (''tú'') du singulier de l’impératif de"); 
  forme.push_back("imp.p.2s2"); terminaison.push_back("á"); 	 def.push_back("Deuxième personne (''vos'') du singulier de l’impératif de");
  forme.push_back("imp.p.3s");  terminaison.push_back("e"); 	 def.push_back("Troisième personne du singulier de l’impératif de");	    
  forme.push_back("imp.p.1p");  terminaison.push_back("emos");	 def.push_back("Première personne du pluriel de l’impératif de"); 	    
  forme.push_back("imp.p.2p");  terminaison.push_back("ad");	 def.push_back("Deuxième personne du pluriel de l’impératif de"); 	    
  forme.push_back("imp.p.3p");  terminaison.push_back("en");	 def.push_back("Troisième personne du pluriel de l’impératif de");           
  

  ifstream ifile("liste_aTraiter_es.txt");
  if(!ifile) {
    cout << "Probleme a l'ouverture de liste_aTraiter_es.txt" << endl;
    return -1;
  }
  vector < string > article;
  string line;
  while(getline(ifile,line)) {
    article.push_back(line);
  }
  ifile.close();

  ifstream cofile("liste_chgt_ortho_es.txt");
  if(!cofile) {
    cout << "Probleme a l'ouverture de liste_chgt_ortho_es.txt" << endl;
    return -1;
  }
  vector < string > changementOrthographique;
  while(getline(cofile,line)) {
    changementOrthographique.push_back(line);
  }
  cofile.close();


  bool aTraiter;

  vector < string > terminaisonTraitee;
  vector < unsigned int > index;

  ofstream ofile("es_conj.xml");
  ofstream ofile2("es_formes_crees.txt");
  ofstream ofile3("es_verif_supp.txt");
  for(unsigned int i=0 ; i</*100*/article.size() ; i++)
    {
      //on verifie que le verbe se finit par « -ar »
      //cout << "article[i].rfind(\"ar\") : " << article[i].rfind("ar") << " " << endl;
      if(article[i].rfind("ar") != article[i].length()-2) continue;

      //on ne traite pas pour le moment les verbes qui changent d'orthographe
      // (sauf les verbes en -car, -gar et -zar)
      aTraiter = true;
      for(int j=0 ; j<changementOrthographique.size() ; j++)
	if(article[i]==changementOrthographique[j]) {
	  if     (article[i].rfind("car") == article[i].length()-3) aTraiter = true;
	  else if(article[i].rfind("gar") == article[i].length()-3) aTraiter = true;
	  else if(article[i].rfind("zar") == article[i].length()-3) aTraiter = true;
	  else {
	    // cout << "chgmt ortho a ne pas traiter: " << article[i] << endl;
	    aTraiter = false;
	  }
	}
      
      if(!aTraiter) {
	ofile3 << article[i] << endl;
	continue;
      }

      string rad = article[i].substr(0,article[i].length()-2);
      cout << "Traitement de " << article[i] << ", radical : " << rad << endl;

      for(int j=0 ; j<terminaison.size() ; j++) {
	//pour chaque terminaison, on verifie si on l'a deja traite
	//si c'est le cas, on passe au suivant
	//sinon on cherche toutes les terminaisons similaires
	//et on stocke le resultat dans le vecteur "index"
	for(unsigned int k=0 ; k<terminaisonTraitee.size() ; k++)
	  if(terminaison[j] == terminaisonTraitee[k])
	    continue;
	terminaisonTraitee.push_back(terminaison[j]);
	
	index.clear();
	for(unsigned int k=0 ; k<terminaison.size() ; k++)
	  if(terminaison[k] == terminaison[j])
	    index.push_back(k);

	string mot = rad + terminaison[j];
	corr_car(ofile3, rad, mot);
	corr_gar(ofile3, rad, mot);
	corr_zar(ofile3, rad, mot);

	ofile2 << mot << endl;

	ofile << "xxxx" << endl
	      << "'''" << mot << "'''" << endl
	      << "{{vérifier création automatique||es}}" << endl
	      << "== {{langue|es}} ==" << endl
	      << "=== {{S|verbe|es|flexion}} ===" << endl
	      << "{{es-verbe-flexion|" << article[i];

	//{{es-verbe-flexion|poder|ind.p.1s=oui}}
	for(unsigned int k=0 ; k<index.size() ; k++)
	  ofile << "|" << forme[index[k]] << "=oui";
	ofile << "}}" << endl;
	
	//'''podemos''' {{pron|poˈdemos|es}}
	ofile << "'''" << mot << "''' {{pron||es}}"<< endl;
	
	//#''Première personne du pluriel du présent de l’indicatif de ''[[poder#es|poder]]''.''
	for(unsigned int k=0 ; k<index.size() ; k++) {
	  int pos = forme[index[k]].find_last_of(".");
	  if(pos==-1) //ppa ou ppr
	    ofile << "#''" << texteDef[forme[index[k]]] << " ''[[" << article[i] << "#es|" << article[i] << "]]''.''" << endl;
	  else {
	    string tmp = forme[index[k]];
	    string pers, temps;
	    pers.assign(tmp,pos,string::npos);
	    temps.assign(tmp,0,pos);
	    ofile << "# ''" << texteDef[pers] << texteDef[temps] << " de ''[[" << article[i] << "#es|" << article[i] << "]]''.''" << endl;
	  }
	}

	//clé de tri
	string cleTri = cleDeTri(mot);
	if(cleTri.size() != 0 )
	  ofile << endl
		<< "{{clé de tri|" << cleTri << "}}" << endl;

	ofile << "yyyy" << endl;
      }
    }
  ofile.close();
  ofile2.close();
  ofile3.close();
  return 1;
}

Créer les pages de conjugaisonModifier

Il faut alors 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 -autosummary -notitle -file:es_conj.xml

Simplifier es_formes_crees.txtModifier

À la sortie de creer_pages_conjugaison_espagnol_1.cpp, es_formes_crees.txt peut contenir deux fois ou plus la même forme. Pour disposer d’une liste sans doublon que l’on utilisera par la suite, nous créons un petit programme c++ que l’on enregistre sous clean_list.cpp.

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

using namespace std;

int main(int argc, char **argv) {
  ofstream ofile("es_formes_crees_uniques.txt");
  ifstream ifile("es_formes_crees.txt");
  string line;
  vector < string > formes;
  bool trouve = false;
  while(getline(ifile,line)) {
    trouve = false;
    for(unsigned int i=0 ; i<formes.size() ; i++)
      if(line == formes[i]) {
        trouve = true;
        break;
      }
    if(trouve) continue;
    formes.push_back(line);
    ofile << line << endl;
  }
  ifile.close();
  ofile.close();
}

On le compile avec la commande

g++ clean_liste.cpp -std=c++11 -o clean

et on le lance en tapant simplement « ./clean » dans le répertoire où se trouve es_formes_crees.txt. À la fin, on dispose d’un nouveau fichier es_formes_crees_uniques.txt qui contient le contenu de es_formes_crees.txt mais sans les doublons.

Identifier les pages qui n’ont pas été crééesModifier

Une fois que toutes les pages ont été importées, nous allons utiliser un autre script bash qui va recenser toutes les pages qui devraient contenir une section espagnole mais qui n’en contiennent pas encore. Cela se fait grâce au script verif_creation_page.sh.

#!/bin/bash
nomFichier="es_formes_crees_uniques.txt"

for line in $(cat $nomFichier);
do
    ligneObtenue=`python core/pwb.py core/scripts/listpages.py -get -page:$line | grep "{{S|verbe|es|flexion}}"`
    if [ $? -eq 1 ]; then #1 signifie que "grep" n’a pas trouve la chaine « {{S|verbe|es|flexion}} » dans l’article
    #echo $ligneObtenue
        echo $line >> liste_aTraiterManuellement_es.txt
    fi
done

Vérifier que les formes créées existent sur es.wiktModifier

Vérifier pour chaque forme créée qu’il existe un interwiki sur es.wikt ou en.wikt permet de vérifier que le bot n’a pas fait d’erreur. Ainsi le but est-il de repérer les formes qui n’ont pas d’interwikis pour les vérifier à la main.

Ensuite, exécuter le script verif_existence_esWikt.sh qui contient le code suivant

#!/bin/bash
nomFichier="es_formes_crees_uniques.txt"

for line in $(cat $nomFichier);
do
    #echo "$line"
    #line=`echo "$line" | awk '{print tolower($0)}'`
    #echo "$line"
    ligneObtenue=`python core/pwb.py core/scripts/listpages.py -get -page:$line -lang:es -family:wiktionary -user:pamputtBot | grep -i "forma verbal"`
    if [ $? -eq 1 ]; then #1 signifie que "grep" n'a pas trouve la chaine
    #echo $ligneObtenue
        echo $line >> nExistePasSurEsWikt.txt
    fi
done