Utente:Alebot/Scripts interattivi

< Utente:Alebot(Reindirizzamento da Utente:Alebot/Scripts)

La situazione si evolve, ho "azzerato" quasi tutti gli script interattivi per riscriverli daccapo, partendo dal "motore".

Altra versione. Analogamente alla precedente, l'avvio da prompt pone due semplici domande: Avvio il bot? (si, s -> predisposizione avvio script a tempo; qualsiasi altro input, esce nel prompt python) Secondi: (impostare il numero di secondi fra i cicli)

Al momento esegue una lttura di eventuali query intersezione ogni ciclo, e una verifica di nuove pagine nei nsPrincipale, nsAutore, nsIndice e nsPagina ogni due cicli.

  • Aggiornamento 20 luglio 2010, ch'è dentro anche builder(), buildNs0() (versione da correggere), e appena aggiunto accoppaPagine() che esegue la conversione Pagina -> pages index

Avviso a chi si avventura nella lettura: si tratta di un'orrenda collezione di funzioni, scritte secondo un ordine "push": scrivo le nuove funzioni in testa per trovarle ;-). Ossia: non hanno alcun ordine logico. Unico indizio: la routine fondamentale, che esegue l'elaborazione del testo di ogni pagina che il bot trova in UltimeModifiche, è elabora(). :-)

Siete avvisati.

Aggiornamento 30 agosto 2010Modifica

Lo script è ulteriormente appesantito dalla gestione dei dati introdotti con il tl Ns0; sono state introdotte inoltre due simpatiche routine di correzione automatica:

  1. aggiornamento automatico del SAL delle pagine Indice, con verifica che scatta ad ogni modifica su una pagina dell'indice (eventuali valori SAL erronei, introdotti a mano, sono "rullati" dal calcolo automatico);
  2. verifica presenza del tl Qualità in ogni pagina creata/modificata in Ns0, e in caso di assenza, assegnazione d'ufficio del SAL 25%.

Versione 5.8.10: contiene listaNs0(), sommario(), splittaPagina(), verificaSezioni()

#!/usr/bin/python
# -*- coding: utf-8 -*-
# versione al 30 agosto 2010
import wikipedia
import pickle
import catlib
import pagegenerators
from datetime import date
from dummy_threading import Timer
import query as wquery
import urllib

from time import gmtime, strftime
from random import random
import os,sys




a="{{}}"
b="}}"
autoreCitato={}  

nsobs="0|102|108|110" # principale, autore, pagina, indice
output="cp1252"

wnamespaces={'': 0, 'Principale': 0, 'Discussioni categoria': 15, 'MediaWiki': 8, 'Template': 10,
            'Discussioni portale': 107, 'Categoria': 14, 'Discussioni progetto': 105,
            'Discussioni file': 7, 'Discussioni indice': 111, 'Discussioni aiuto': 13,
            'Media': -2, 'Discussioni template': 11, 'Autore': 102, 'Speciale': -1,
            'Discussioni Wikisource': 5, 'Pagina': 108, 'Utente': 2, 'Wikisource': 4,
            'Progetto': 104, 'Discussioni utente': 3, 'Indice': 110, 'Discussioni pagina': 109,
            'Discussioni MediaWiki': 9, 'Discussione': 1, 'Discussioni autore': 103, 'Portale': 106,
            'File': 6, 'Aiuto': 12}
vecchiePagine=[]

# produce una lista di pagine con prefisso determinato
def prefixGen(prefisso, namespace=None,includeredirects=False):
    generatore=pagegenerators.PrefixingPageGenerator(prefisso,includeredirects=includeredirects, namespace=namespace)
    lista=[]
    for i in generatore:
        lista.append(i.title())
    return lista # restituisce la lista di titoli

#genera i tl|Ns0 nel ns Pagina a partire da page index nella pagina testuale
def pageToNs0(nomePagina):
    testoPagina=leggi_pagina(nomePagina)
    pagesTag=find_stringa(testoPagina,"<pages","/>")
    if pagesTag=="":
        return None,None,None,None
    includiIntestazione=find_stringa(testoPagina.replace("includiIntestazione","IncludiIntestazione"),\
                                     "{{IncludiIntestazione","}}")+"|"
    includiIntestazione=includiIntestazione.replace(" =","=")
    pagesTag=pagesTag.replace(" =","=")
    index={}
    for i in [" index="," from="," to="," fromsection="," tosection="]:
        index[i[1:-1]]=pagesTag.find(i)
      
    l=[]
    for i in ["index","from","to","fromsection","tosection"]:
        elemento=[i,index[i],len(pagesTag)]
        for j in ["index","from","to","fromsection","tosection"]:
            if index[j]>elemento[1] and index[j]<elemento[2]:
                    elemento[2]=index[j]
        l.append([i,pagesTag[elemento[1]:elemento[2]]])
    pagina=""
    sezione=""
    base=""
    sezione1=None
    sezione2=None
    for i in l:
        if i[0]=="from":
            pagina=i[1].replace("from=","").strip()
        if i[0]=="index":
            base=i[1].replace("index=","").strip()
            base=base[1:-1]
        if i[0]=="fromsection":
            sezione=i[1].replace("fromsection=","").strip()
    pagina="Pagina:"+base+"/"+pagina
    if sezione!="":
        sezione1="<section begin="+sezione+" />"
        sezione2='<section begin="'+sezione+'" />'
    ns0="{{Ns0|#1|#2}}"
    ns0=ns0.replace("#1",nomePagina)
    #print includiIntestazione
    titolo=find_stringa(includiIntestazione,"sottotitolo=","|").strip()
    ns0=ns0.replace("#2",titolo)
    
    return ns0,pagina,sezione1,sezione2

# estrae i dati da una pagina Indice e restituisce una lista

##def elencoLinksIndice(indice="Indice:Africa orrenda.djvu"):
##    tutte=True
##    site=wikipedia.getSite()
##    page=wikipedia.Page(site,indice)
##
##    # calcolo nome x url
##    nomeindice="/wiki/"+page.urlname()
##    
##    #lettura HTML originario (prima delle alterazioni js)
##    testo=leggi_pagina_html(nomeindice)
##    #ricerca di tutti i tag <a href..>...</a> e salvataggio su file
##    pagine=produci_lista(testo,'<a href="',"</a>",1)
##    
##    link=[]
##    for i in pagine:
##         
##       if ('title="Pagina:' in i) and ("class=" in i):
##           
##           if not titolo in titoli:
##               
##               link.append(i)
##    return links
##    

def elencoPagineIndice(indice="Indice:Ardigo - Scritti vari.djvu",tutte=False,links=False):
    #elenco_pagine=[]
    #inizializzazione oggetto Page su pagina indice
    site=wikipedia.getSite()
    page=wikipedia.Page(site,indice)

    # calcolo nome x url
    nomeindice="/wiki/"+page.urlname()
    
    #lettura HTML originario (prima delle alterazioni js)
    testo=leggi_pagina_html(nomeindice)
    #print testo
    salva_pcl(testo,"testoIndice")
    
    #ricerca di tutti i tag <a href..>...</a> e salvataggio su file
    pagine=produci_lista(testo,'<a href="',"</a>",1)
    print "Numero elementi totali:",len(pagine)
    titoli=[]
    link=[]
    for i in pagine:
         if tutte:
           if ('title="Pagina:' in i) and ("class=" in i):
               titolo=find_stringa(i,'title="','"').replace(" (tuttora non scritto)","")
               #print titolo
               #qp=find_stringa(i,'class="','"')
               if not titolo in titoli:
                   #elenco_pagine.append([titolo,qp])
                   titoli.append(titolo)
                   link.append(i)
                   #print i,
         else:
            if ('title="Pagina:' in i) and ("class=" in i) and (not " (tuttora non scritto)" in i):
               titolo=find_stringa(i,'title="','"')
               if not titolo in titoli:
                  titoli.append(titolo)
                  link.append(i)
                  
   
    if links:
       risultato=link
    else:
       risultato=titoli
       

    return risultato

# restutuisce un dizionario delle pagine in una pagina Incide, accoppiate con la
# loro rappresentazione impostata da pagelist
def estraiDatiLinks(indice): # riceve da estraiPagineIndice una lista di links
    
   result={}
   lista=elencoPagineIndice(indice,False,True)
   for i in lista:
      link=i
      qp=find_stringa(link,'class="','"')
      titolo=find_stringa(link,'title="','"')
      span=find_stringa(link,"<span","</span>",1)
      if span>"":
         link=link.replace(span,"")
      ancora=find_stringa(link,">","<")
      result[titolo]=[ancora,qp]
   return result

def pagine2djvu(result):
    
    links={}
    for i in result.keys():
        links[result[i][0]]="[[../"+i[i.find("/")+1:]+"|"+result[i][0]+"]]"
    return links

def rigaIndice(testo):
    l=testo.split("\n")
    for i in range(len(l)):
        if l[i].startswith(":"):
            l[i]=l[i][1:]
            riga=l[i].split(" ")
            ri=riga.pop(0)
            rf=riga.pop()
            riga=" ".join(riga)
            riga="{{RigaIndice|"+ri+"|"+riga+"|"+rf+"}}"
            l[i]=riga
    testo="\n".join(l)
    return testo

# esegue aggiornamento massivo della Qualità in un'intera opera
def aggiustaQualita(prefisso, avz="75%", data="31 luglio 2010",arg="novelle"):
    n=0
    base=u"{{Qualità|avz=#avz#|data=#data#|arg=#arg#}}".replace("#avz#",avz)\
.replace("#data#",data).replace("#arg#",arg)
    lista=prefixGen(prefisso)
    for nomePagina in lista:
        testo=leggi_pagina(nomePagina)
##        print testo
        q=find_stringa(testo,u"{{Qualità|","}}",1)
        if q!="":
            testo=testo.replace(q,"")
        testo=base+testo
        testo=elaboraTesto(testo)
        scrivi_pagina(testo,False,nomePagina,commento=u"Aggiornamento tl qualità via bot")
    return
        
# batch di elaborazione di un testo (varie routine)
def elaboraTesto(testo):
    testo=apos(testo)
    testo=conteggioPagine(testo)
    testo=accoppaCapitolo(testo)
    testo=accoppaPagina(testo)
    return testo                     
    
    
def aggiungiQualita(lista,numeromax=10000):
    n=0
    q=u"{{Qualità|avz=indeterminato|data=27 luglio 2010|arg=Da definire}}"
    for i in lista:
        nomePag=i
        testo=leggi_pagina(nomePag)
        if not u"{{Qualità|" in testo:
            print testo[:300]
            if "{{Intestazione" in testo or "{{IncludiIntestazione" in testo:
                testo=accoppaCapitolo(q+testo)
                scrivi_pagina(testo,False,nomePag,commento=u"Aggiunta template qualità indeterminata")
                n=n+1
                
                if n>numeromax:
                    break
    return


def pagineToPagesIndex(lista):
    
   for capitolo in lista:
      testoCapitolo=leggi_pagina(capitolo)
      testoCapitolo1=accoppaPagina(testoCapitolo)
      if testoCapitolo1!=testoCapitolo:

         scrivi_pagina(testoCapitolo,False,capitolo,"Conversione pagine->pages index via bot")
      
   return
   
def accoppaPagina(testoCapitolo):
   pagesIndex='<pages index= from= to= fromsection= tosection= />'
   testoCapitolo=testoCapitolo.replace("{{Pagina","{{pagina")
   #print capitolo
   if testoCapitolo.count("{{pagina")>0:
      print testoCapitolo
      pagine=produci_lista(testoCapitolo,"{{pagina","}}",1)
      for i in pagine:
         if not (".djvu/" in i.lower() or ".pdf/" in i.lower()):
            return testoCapitolo
      print pagine
      base=find_stringa(pagine[0],"pagina|","/")
      pi=pagesIndex.replace("index=","index="+'"'+base+'"')
      l=[]
      for i in pagine:
          if i.count("|")==2:
              l1=find_stringa(i,"/","|")
              l2=find_stringa(i,"section=","}}")
          else:
              l1=find_stringa(i,"/","}}")
              l2=""
          l.append([eval(l1),l2])
      l.sort()
      lmin=min(l)
      lmax=max(l)
      pi=pi.replace("from=","from="+str(lmin[0]))
      pi=pi.replace("to=","to="+str(lmax[0]))
      if lmin[1]>"":
          pi=pi.replace("fromsection=","fromsection="+lmin[1])
      if lmax[1]>"":
          pi=pi.replace("tosection=","tosection="+lmax[1])
      for i in range(len(pagine)):
          if i==0:
              testoCapitolo=testoCapitolo.replace(pagine[i],pi)
          else:
              testoCapitolo=testoCapitolo.replace(pagine[i],"")
      print pi
   return testoCapitolo

# script di sola visualizzazione, non modifica wiki
def allineaNs0(nomePagina):
   testoPagina=leggi_pagina(nomePagina)
   includiIntestazione=find_stringa(testoPagina,"{{IncludiIntestazione|","}}",1)
   sottotitolo=find_stringa(includiIntestazione,"sottotitolo=","|").strip()
   if sottotitolo=="":
      sottotitolo=find_stringa(includiIntestazione,"sottotitolo=","}}").strip()
   
   #print testoPagina
   pageIndex=find_stringa(testoPagina,"<pages index","/>",1)
   if pageIndex>"":
      nPag=find_stringa(pageIndex,"from="," ")
      nSec=find_stringa(pageIndex,"fromsection="," ")
      index=find_stringa(pageIndex,'index="','"')
      parti=nomePagina.split("/")
      nomePag=parti[len(parti)-1]
      nomeMain=parti[0]
      if len(parti)>2:
         prefisso="/".join(parti[1:len(parti)-1])+"/"
      else:
         prefisso="/"
      ns0="{{Ns0|"+prefisso+nomePag+"|"+sottotitolo+"}}"
      print "Ns0:",ns0
     
   return
      
# vecchio script di conversione precedente infotesto
def normalizzaInfotesto(progetto):
   pagina=wikipedia.Page("it","Template:Infotesto "+progetto)
   lista=pagina.getReferences(onlyTemplateInclusion=True)
   for i in lista:
      if not ("/" in i.title() or "Discussioni pagina:" in i.title()):
         print i.title()
         testo=i.get()
         #print testo
         testoNew=testo.replace("Infotesto "+progetto,"Infotesto\n| Progetto= "+progetto)
         if testoNew!=testo:
            
            scrivi_pagina(testoNew,False,i.title(),commento="Normalizzazione Infotesto")
   return


def normalizzaInfotestoSottopagine(progetto):
   pagina=wikipedia.Page("it","Template:Infotesto "+progetto)
   lista=pagina.getReferences(onlyTemplateInclusion=True)
   for i in lista:
      if "Discussione:" in i.title() and "/" in i.title():
         print i.title()
         testo=i.get()
         #print testo
         infotesto=find_stringa(testo,"{{Infotesto","}}",1)
         if infotesto!="":
            
            testoNew=testo.replace(infotesto,"{{IncludiInfotesto}}")
            if testoNew!=testo:
               print testoNew
               scrivi_pagina(testoNew,False,i.title(),commento="Normalizzazione Infotesto")
   return

def creaPrecSucc(paginaPrincipale="Sentenza Tribunale penale di Perugia - Vicenda Federconsorzi"):
   testo=leggi_pagina(paginaPrincipale).replace("{{Testo","{{testo")
   lista=produci_lista(testo,"{{testo","}}",1)
   print "la pagina contiene ",len(lista),"link a sottopagine"
   for i in range(len(lista)):
      param=find_stringa(lista[i],"{{","}}").split("|")[1]
      if param.startswith("/"):
         lista[i]=paginaPrincipale+param
         
      else:
         lista[i]=param
   #print lista
   for i in range(len(lista)):
      nomePag=lista[i]
      linkPagPrec=""
      linkPagSucc=""
      if not i==0:
         linkPagPrec=abs2rel(lista[i],lista[i-1])
      if not i==len(lista)-1:
         linkPagSucc=abs2rel(lista[i],lista[i+1])
      testo=leggi_pagina(nomePag).replace("{{includiIntestazione","{{IncludiIntestazione")
      incInt=find_stringa(testo,"{{IncludiIntestazione","}}",1)
      incIntNew=incInt.replace("prec =","prec=").replace("succ =","succ=")
      if not ("prec=" in incIntNew or "succ=" in incIntNew):
         incIntNew=incIntNew.replace("}}","|prec="+linkPagPrec+"}}").replace("}}","|succ="+linkPagSucc+"}}")
         testo1=testo.replace(incInt,incIntNew).replace("}}==","}}\n==")
         scrivi_pagina(testo1,False,nomePag)
      elif "}}==" in testo:
         scrivi_pagina(testo.replace("}}==","}}\n=="),False,nomePag)
 
   return

def abs2rel(nomePagina,link):# restituisce titolo2 relativo
    nomePagina=nomePagina.split("/")
    link=link.split("/")
    abs2=[]
    for i in range(len(nomePagina)):
        abs2.append("..")
    while nomePagina[0]==link[0]:
        
        nomePagina.pop(0)
        link.pop(0)
        abs2.pop()
        if len(nomePagina)==0 or len(link)==0:
            break
        
    result="/".join(abs2+link)
    if result.endswith(".."):
        result=result+"/"
    if not result.startswith(".."):
        result="/"+result
    return result

   
def fixDjvu(testo):
   header=find_stringa(testo,u"\u2014","\n",1)
   testo=testo.replace(header,"")
   testo=testo.replace(u"\ufffd\ufffd","<poem>",1)
   testo=testo.replace(u"\n\n\ufffd\ufffd","</poem>",1)
   testo=testo.replace(u"\ufffd","")
   
   
   return testo

def riempiPagine(indice):
   if indice.startswith("Indice:"):
      base=indice.replace("Indice:","Pagina:")+"/"
   else:
      base="Pagina:"+base+"/"
   n=1
   while True:
      n=raw_input("Numero pagine")
      if n.isdigit():
         n=eval(n)
         break
   for i in range(1,n):
      testo=leggi_pagina(base+str(i))
      if testo=="":
         scrivi_pagina("<!-- qui testo -->",False,base+str(i))
   return
      
  
def buildNs0(listaNs0, baseIndex=None,scrivi=False, riscrivi=False): # riceve il nome di una pagina ns0 principale e la lista ln
                        # prodotta da builder()
  
      
   capitoli=[]
   schema=u'''{{Qualità|avz=50%|data=7 agosto 2010|arg=poesie}}{{IncludiIntestazione
| Argomento=Filosofia
| sottotitolo = #sottotitolo#
| prec = #prec#
| succ = #succ#
}}

<pages index="#baseindex#" from=#from# to=#to# fromsection=#fromsection# tosection=#tosection# />

{{Sezione note}}
{{Conteggio pagine|[[Speciale:Statistiche]]}}'''
   for i in range(len(listaNs0)):
      capitolo=schema
      dc=find_stringa(listaNs0[i][1],"{{Ns0|","}}").split("|")
      nomeCapitolo=dc[0]
      titoloCapitolo=dc[1]
      capitolo=capitolo.replace("#sottotitolo#",titoloCapitolo)\
                .replace("#baseindex#",baseIndex)\
                .replace("#from#",listaNs0[i][4])\
                .replace("#to#",listaNs0[i][6])\
                .replace("#fromsection#",listaNs0[i][5])\
                .replace("#tosection#",listaNs0[i][7])

      capitolo=capitolo.replace("#prec#",listaNs0[i][8])
      if i<len(listaNs0)-1:
          capitolo=capitolo.replace("#succ#",listaNs0[i][9])
      else:
          capitolo=capitolo.replace("#succ#","")
      print capitolo
##      nomeCapitolo=main+"/"+listaNs0[i][0]
      capitoli.append([nomeCapitolo,capitolo])
      if riscrivi:
         scrivi_pagina(capitolo, False,nomeCapitolo,"Riscrittura capitolo via bot")
      
      elif scrivi:
         if leggi_pagina(nomeCapitolo)=='':
            scrivi_pagina(capitolo, False,nomeCapitolo,"Creazione capitolo via bot")
      
   return capitoli

# la routine suddivide una pagina Pagina in header, testo, footer
# e segmenta il testo 
def splittaPagina(pagina): # riceve il testo Unicode della pagina
   header=find_stringa(pagina,"<noinclude><page","</noinclude>",1)
   footer=find_stringa(pagina,"<noinclude>\n<ref","</noinclude>",1)
   testo=pagina.replace(header,"").replace(footer,"")
   testo=splittaTesto(testo)
   
   return [header, testo, footer]

# la routine suddivide il testo in una lista di segmenti tipo testo, tipo ns0
# o tipo section

def convertiQuality(testo):
    qualityTemplate=find_stringa(testo,"{{PageQuality","}}",1)
    lq=find_stringa(qualityTemplate, "{{PageQuality|","}}").split("|")
    schema='<pagequality level="#1" user="Alebot" />'
    nquality=schema.replace("#1",lq[0])
    testo=testo.replace(qualityTemplate,nquality)
    return testo
    
def aggiornaListaNs0(nomePaginaPrincipale):
    listacapitoli=prefixGen(nomePaginaPrincipale)
    for i in listacapitoli:
        pag=wikipedia.Page("it",i)
        nomePagina=pag.title()
        if pag.isRedirectPage():
            print nomePagina,u" è un redirect"
        elif pag.isDisambig():
            print nomePagina,u" è una pagina disambigua"
        elif not pag.exists():
            print nomePagina,u" non esiste"
        else:
            aggiornaNs0(nomePagina)
    return


def aggiornaNs0(titolo):
    dati=pageToNs0(titolo) #    return ns0,pagina,sezione1,sezione2
    print dati
    if dati[1]==None:
        return "testo ",titolo,"senza tag pages index"
    testoPagina=leggi_pagina(dati[1])
    if "{{PageQuality" in testoPagina:
        testoPagina=convertiQuality(testoPagina)
        
    header,testo,footer=splittaPagina(testoPagina)
#    testoback=testo[:]
    nt=[]

    if dati[2]==None:
##        for i in testo:
##            if tipoSegmento(i)!="ns0":
##                nt.append(i)
##        testo=nt[:]
        if tipoSegmento(testo[0])=="ns0":
            testo[0]=dati[0]
        else:
            testo[0:0]=dati[0]
    else:
        if dati[2] in testo:
            sectPos=testo.index(dati[2])
            if tipoSegmento(testo[sectPos+1])!="ns0":
                testo[sectPos+1:sectPos+1]=dati[0]
            else:
                testo[sectPos+1]=dati[0]
        if dati[3] in testo:
            sectPos=testo.index(dati[3])
            if tipoSegmento(testo[sectPos+1])!="ns0":
                testo[sectPos+1:sectPos+1]=dati[0]
            else:
                testo[sectPos+1]=dati[0]
        
        else:
            print "Errore:section",dati[2],dati[3]," non trovata in ",dati[1]
#            testo=testoback
        
    testoPaginaNew="".join([header,"".join(testo),footer])
    if testoPaginaNew==testoPagina:
        print "Nessuna modifica"
    else:
        scrivi_pagina(testoPaginaNew,False,dati[1],"Aggiornamento Ns0 via aggiornaNs0()")
    return
            
    

    

def splittaTesto(testo): # new 1 8 2010
    testo=testo.replace("{{ns0","{{Ns0").replace(u"\ufeff","")
    lista=[]
    while "{{Ns0" in testo:
        if testo.startswith("{{Ns0"):
            ns0=find_stringa(testo,"{{Ns0","}}",1)
            lista.append(ns0)
            testo=testo.replace(ns0,"",1)
        else:
            segmento=testo[:testo.find("{{Ns0")]
            
            testo=testo.replace(segmento,"",1)
            segmento=splittaSegmento(segmento)
            lista=lista+segmento
    if len(testo)>0:
        testo=splittaSegmento(testo)
        lista=lista+testo
        testo=""
    return lista

def splittaSegmento(testo): 
    lista=[]
    while "<section" in testo:
        if testo.startswith("<section"):
            section=find_stringa(testo,"<section","/>",1)
            lista.append(section)
            testo=testo.replace(section,"",1)
        else:
            segmento=testo[:testo.find("<section")]
            testo=testo.replace(segmento,"",1)
            lista.append(segmento)
    if len(testo)>0:
        lista.append(testo)
    return lista
        
# la routine restituisce il tipo di un segmento del testo
def tipoSegmento(testo):
    if testo.startswith("<section"):
        tipo="section"
    elif testo.startswith("{{Ns0"):
        tipo="ns0"
    elif "<pagequality" in testo:
        tipo="header"
    elif "<references/>" in testo:
        tipo="footer"
    else:
        tipo="testo"
    return tipo
                           
# la routine elimina eventuali section e le riscrive in modo regolare
# restituisce un testo segmentato 
def verificaSezioni(testo): # testo è lista di segmenti
    if len(testo)<2 and tipoSegmento(testo[0])=="testo":
        True
    elif len(testo)==2 and tipoSegmento(testo[0])=="ns0":
        True
    else:
        testo0=testo[:]
        testo=[]
        for i in testo0:
            if tipoSegmento(i) in "ns0/testo": #qui le section esistenti vengono saltate
                testo.append(i)
        n=1
        for i in range(len(testo)):
            if i==0 and tipoSegmento(testo[i])=="testo":
                testo[i]="<section begin=x />".replace("x",str(n))+testo[i]+\
                          "<section end=x />".replace("x",str(n))
                n+=1
            elif tipoSegmento(testo[i])=="ns0":
                testo[i]="<section begin=x />".replace("x",str(n))+testo[i]
                if i==len(testo)-1:
                    testo[i]=testo[i]+"<section end=x />".replace("x",str(n))
                else:
                    testo[i+1]=testo[i+1]+"<section end=x />".replace("x",str(n))
                n+=1
        testo="".join(testo)
        testo=splittaTesto(testo)
    return testo

def ripassaNs0(base="Ardigo - Scritti vari.djvu",ini=200,fin=300):
    for i in range(ini,fin):
        nomePagina="Pagina:"+base+"/"+str(i)
        addSectionTag(nomePagina)
    return
        
    


def addSectionTag(nomePagina): # riceve un nome di pagina e normalizza le section
    testoPaginaOriginale=leggi_pagina(nomePagina)
    testoPagina=addSectionTagEngine(testoPaginaOriginale)
    if testoPagina!=testoPaginaOriginale:
        scrivi_pagina(testoPagina,False,nomePagina,commento="Normalizzazione section via bot")
    return

def addSectionTagEngine(testoPagina):
    
    sectionvoc={}
    listasec=produci_lista(testoPagina,"<section","/>",1)
    for i in listasec:
        if not i in ["<section begin=1 />","<section end=1 />","<section begin=2 />","<section end=2 />",\
                     "<section begin=3 />","<section end=3 />","<section begin=4 />","<section end=4 />",\
                     "<section begin=5 />","<section end=5 />","<section begin=6 />","<section end=6 />"]:
            sectionvoc[i.replace("<section","<*section")]=i
            sectionvoc[i]=i.replace("<section","<*section")
            testoPagina=testoPagina.replace(i,sectionvoc[i])
    
    testoPagina=splittaPagina(testoPagina)
    #print testoPagina
    if testoPagina[1]!=[]:
        
        testo=verificaSezioni(testoPagina[1])
        
        if testo!=testoPagina[1]:
            user=find_stringa(testoPagina[0],'user="','"',1)
            testoPagina[0]=testoPagina[0].replace(user,'user="Alebot"')
            testoPagina[1]="".join(testo)
        else:
            testoPagina[1]="".join(testo)
            
            
    testoPagina="".join(testoPagina)
            
    recsec=produci_lista(testoPagina,"<*section","/>",1)
    for i in recsec:
        testoPagina=testoPagina.replace(i,sectionvoc[i])
               
    return testoPagina
    

# trova le pagine di nome base in cui è usato Ns0 e produce una lista di coppie
# nomePagina,Ns0
def listaNs0(base="Ardigo - Scritti vari.djvu",filtro=False):
    l=[]
    p=wikipedia.Page("it","Template:Ns0").getReferences(onlyTemplateInclusion=True)
    pagineNs0=[]
    for i in p:
        if "Pagina:"+base in i.title():
            pagineNs0.append(i)
    
    datiPagine=estraiDatiLinks("Indice:"+base)
    
    for i in range(len(pagineNs0)):
        pagineNs0[i]=[eval(pagineNs0[i].title().replace("Pagina:"+base+"/","")),pagineNs0[i]]
    pagineNs0.sort()
    for i in range(len(pagineNs0)):
        pagineNs0[i]=pagineNs0[i][1]
        
    
    for i in pagineNs0:
        titolo=i.title()
        if base in titolo:
            print titolo
            testo=i.get()
            itemsNs0=produci_lista(testo,"{{Ns0","}}",1)
            for tlNs0 in itemsNs0:
                l.append([titolo,tlNs0,datiPagine[titolo][0],splittaPagina(testo)])
    if filtro:
        p=[]
        for i in l:
            if filtro in i[1]:
                p.append(i)
        l=p[:]
    
    #l=sortNs0(l,base)
    l=elaboraNs0(l)
    return l

def sortNs0(l,base):
    lo=[]
    n=1
    for i in l:
        #print i[0], base+"/","|"
        npag=find_stringa(i[0]+"|",base+"/","|")
        if npag!="":
            #print npag,
            npag=eval(npag)
            lo.append([npag,n,i])
            n+=1
    lo.sort()
    l=[]
    for i in lo:
        l.append(i[2])
    return l

def numeroPagina(pagina): # restituisce il numero di una pagina dal nome pagina
    numero=find_stringa(pagina+"##","/","##",side="rigth")
    return numero

def nomeSezione(sezione): # restituisce il nome di una section
    nome=find_stringa(sezione,"<section begin="," />").strip()
    if nome=="":
        nome=find_stringa(sezione,"<section end="," />").strip()
    if nome.startswith('"') and nome.endswith('"'):
        nome=nome[1:-1]
    return nome
    

def elaboraNs0(lista): # aggiunge vari tag a listaNs0 "grezza"
    if len(lista[0])<5:
        for i in range(len(lista)):
            lista[i]=lista[i]+["","","","","",""] # from, fromsection, to, tosection, prec, succ
    for i in  range(len(lista)):
        
        #print i,lista[i]
        segmenti=lista[i][3][1]
        ns0cor=lista[i][1]
        indexNs0=segmenti.index(ns0cor)
        paginaCorrente=numeroPagina(lista[i][0])
        if i==0:  # se si tratta del primo ns0 del libro
            lista[i][4]=paginaCorrente #carica in from il numero della pagina
            if indexNs0==1: #ed è una pagina con section
                lista[i][5]=nomeSezione(segmenti[0]) # allora carica la section begin in fromsection di ns0 corrente
                                                     # non vi sono ns0 precedenti di cui aggiornare il to / tosection
        else: # se si tratta di un ns0 successivo allora occorre aggiornare anche il to /tosection del ns0 precedente
            lista[i][4]=paginaCorrente #carica in from il numero della pagina
            if indexNs0>0:
                lista[i][5]=nomeSezione(segmenti[indexNs0-1]) # allora carica la section begin in fromsection di ns0 corrente
            if indexNs0==0 or indexNs0==1: # se ns0 è a inizio pagina allora to del ns0 precedente è numero pagina corrente -1
                lista[i-1][6]=str(eval(paginaCorrente)-1)
            else:
                lista[i-1][6]=paginaCorrente
                lista[i-1][7]=nomeSezione(segmenti[indexNs0-2])
        capCor=find_stringa(lista[i][1],"{{Ns0|","|")
        if i==0:
            lista[i][8]="../"
            lista[i][9]=abs2rel(capCor,find_stringa(lista[i+1][1],"{{Ns0|","|"))
        elif i<len(lista)-1:
            lista[i][8]=abs2rel(capCor,find_stringa(lista[i-1][1],"{{Ns0|","|"))
            lista[i][9]=abs2rel(capCor,find_stringa(lista[i+1][1],"{{Ns0|","|"))
        else:
            lista[i][8]=abs2rel(capCor,find_stringa(lista[i-1][1],"{{Ns0|","|"))

    return lista

                                              
def estraiDatiLinks(indice): # riceve da estraiPagineIndice una lista di links
   result={}
   lista=elencoPagineIndiceOld(indice,False,True)
   for i in lista:
      link=i
      qp=find_stringa(link,'class="','"')
      titolo=find_stringa(link,'title="','"')
      span=find_stringa(link,"<span","</span>",1)
      if span>"":
         link=link.replace(span,"")
      ancora=find_stringa(link,">","<")
      result[titolo]=[ancora,qp]
   return result # restituisce un vocabolario 

def elencoPagineIndiceOld(indice="Indice:Ardigo - Scritti vari.djvu",tutte=False,links=False):
    #riceve il nome di una pagina indice e estrae i dati delle pagine
    #se tutte=True, restituisce anche le pagine non esistenti
    #inizializzazione oggetto Page su pagina indice
    #site=wikipedia.getSite()
    page=wikipedia.Page("it",indice)

    # calcolo nome x url
    nomeindice="/wiki/"+page.urlname()
    
    #lettura HTML originario (prima delle alterazioni js)
    testo=leggi_pagina_html(nomeindice)
    
    #ricerca di tutti i tag <a href..>...</a> e salvataggio su file
    pagine=produci_lista(testo,'<a href="',"</a>",1)
    titoli=[]
    link=[]
    for i in pagine:
         if tutte:
           if ('title="Pagina:' in i) and ("class=" in i):
               titolo=find_stringa(i,'title="','"').replace(" (tuttora non scritto)","")
               #qp=find_stringa(i,'class="','"')
               if not titolo in titoli:
                   #elenco_pagine.append([titolo,qp])
                   titoli.append(titolo)
                   link.append(i)
         else:
            if ('title="Pagina:' in i) and ("class=" in i) and (not " (tuttora non scritto)" in i):
               titolo=find_stringa(i,'title="','"')
               if not titolo in titoli:
                  titoli.append(titolo)
                  link.append(i)
                  
   
    if links:
       risultato=link
    else:
       risultato=titoli
       

    return risultato
    
    
# riceve una lista prodotta  da listaNs0 e produce un sommario
# Al momento fornisce il titolo link alla pagina reale

def sommario(lista,addit=0):
   item=" {{Indice sommario|0|#Pagina|#Titolo|#Numero}}"
   sommario=[]
   for i in lista:
      itemc=item
      itemc=itemc.replace("#Pagina",i[0].replace("Pagina:",""))
      itemc=itemc.replace("#Numero",i[2])
      if len(i[1].split("|"))==3:
          itemc=itemc.replace("#Titolo",i[1].split("|")[2].replace("}}",""))
      else:
          np=i[1].split("|")[1].replace("}}","")
          np=np.split("/")
          titolo=np[len(np)-1]
          itemc=itemc.replace("#Titolo",titolo)
      sommario.append("*"*(i[1].count("/")+addit)+itemc)
   return "\n".join(sommario)         
            

# fornisce una lista dei testi delle pagine di un indice (elemento
#iniziale vuoto in modo che l[1]=pagina/1
def pageDownloader(base, site="it"):
   l=[]
   l.append([])
   if site=="it":
      if base.startswith("Indice:"):
         base=base.replace("Indice:","Pagina:")
      if not base.startswith("Pagina:"):
         base="Pagina:"+base
   if not base.endswith("/"):
      base+="/"
      
   n=1
   while True:
      pagina=leggi_pagina(base+str(n), site)
      if pagina=="":
         break
      l.append(splittaPagina(pagina))
      print "Caricata pagina:", base+str(n)
      n+=1
   salva_pcl(l,base.replace(".","_").replace(":","_").replace("/","_"))
   return l



      

def rc(rcstart=None,rcend=None,number=50,namespace="0|102|108|110",rcshow="!bot!redirect",rctype="edit|new"):
   ''' modulo per la lettura di number eventi da recentchanges

   Restituisce l'ultimo timestamp letto e una lista di eventi, in cui sono eliminati i doppioni (edit sulle stesse pagine).
   La lista va ulteriormente depurata dai doppioni letti nella stessa sessione (testare il valore number ideale per leggere
   l'intera lista in una sola lettura)'''
   sito=wikipedia.Site("it")
   listgen=sito.recentchanges(number=number,rcstart=rcstart,rcshow=rcshow,rctype=rctype,namespace=namespace)
   lista=[]
   for i in listgen:
      lista.append(i)

   return lista

def iw(ini,fin):
   for p in range(ini,fin):
      nomePagina="Pagina:Canti (Sole).pdf/"+str(p)
      testoPagina=leggi_pagina(nomePagina)
      header=find_stringa(testoPagina,"<noinclude><page","</noinclude>",1)
      footer=find_stringa(testoPagina,"<noinclude>\n<ref","</noinclude>",1)
      testoPagina=find_stringa(testoPagina,header,footer)
      testoPagina=testoPagina.replace(find_stringa(testoPagina,"<noinclude>","</noinclude>",1),"")
      while find_stringa(testoPagina,"<ref>","</ref>",1)!="":
         testoPagina=testoPagina.replace(find_stringa(testoPagina,"<ref>","</ref>",1),"")
      testoPagina="<section begin=1 />"+testoPagina+"<section end=1 /><noinclude>\n\n\n{{Iwpage|la|1}}</noinclude>"
      print header+testoPagina+footer
      scrivi_pagina(header+testoPagina+footer,False,nomePagina)
   return
def testAutore(autore): # autore: istanza Autore o titolo pagina Autore
   preDati='<!--non modificare da qui:--><includeonly><section begin=dati />'
   postDati='<section end=dati /></includeonly><!-- a qui-->'
   if isinstance(autore, type("stringa")):
      autore=wikipedia.Page(wikipedia.Site("it"), autore)
   autore=Autore(autore)
   #datiAttuali=find_stringa(autore.dati,preDati,postDati).split("/")
   d=find_stringa(autore.testo,preDati,postDati)
   if d=='':
      print "Autore:"+autore.nome+" "+autore.cognome+" ",
      print "La sezione dati non esiste"
      return
   else:
      d=d.split("/")
   
   modifiche=False
   campi_mod=[]
   if d[0]!=autore.nome:
      campi_mod.append("nome")
      modifiche=True
   if d[1]!=autore.cognome:
      campi_mod.append("cognome")
      modifiche=True
   if d[6]!=autore.gm_nascita:
      campi_mod.append("gm_nascita")
      modifiche=True
   if d[7]!=autore.a_nascita:
      campi_mod.append("a_nascita")
      modifiche=True
   if d[8]!=autore.gm_morte:
      campi_mod.append("gm_morte")
      modifiche=True
   if d[9]!=autore.a_morte:
      campi_mod.append("a_morte")
      modifiche=True
   if d[10]!=autore.secolo:
      campi_mod.append("secolo")
      modifiche=True
   if d[11]!=autore.secolo2:
      campi_mod.append("secolo2")
      modifiche=True
   if d[12]!=autore.prof_naz:
      campi_mod.append("prof_naz")
      modifiche=True
   if d[13]!=autore.wikipedia:
      campi_mod.append("wikipedia")
      modifiche=True
   if d[14]!=autore.wikiquote:
      campi_mod.append("wikiquote")
      modifiche=True
   if d[15]!=autore.wikinotizie:
      campi_mod.append("wikinotizie")
      modifiche=True
   if d[16]!=autore.commons:
      campi_mod.append("commons")
      modifiche=True
      
   print "Autore:"+autore.nome+" "+autore.cognome+" "   
   if not modifiche:
      print "I dati non sono stati modificati"
   else:
      print "Sono stati modificati:",
      for i in campi_mod:
         print i,
      print
      
   return 

def accoppaCapitolo(testo): # {{}}
   testo_old=testo
   testo=testo.replace("{{Capitolo","{{capitolo")
   if not "{{capitolo" in testo:
      return testo_old
   capitoli=produci_lista(testo,"{{capitolo","}}",1)
   for i in capitoli:
      testo=testo.replace(i,"")
   # estrazione parametri
   capitolo=capitoli[0]
   capitolo=capitolo.replace("|","\n|").replace("}}","\n}}")
   while " =" in capitolo:
      capitolo=capitolo.replace(" =","=")
   while "= " in capitolo:
      capitolo=capitolo.replace("= ","=")
   '''    {{Capitolo
    | CapitoloPrecedente = Titolo del capitolo predente
    | NomePaginaCapitoloPrecedente = Nome della pagina del capitolo precedente
    | CapitoloSuccessivo = Titolo del capitolo successivo
    | NomePaginaCapitoloSuccessivo = Nome della pagina del capitolo successivo
    }} '''
   '''
{{capitolo
|TitoloOpera=I Canti di Castelvecchio
|NomePaginaOpera=I Canti di Castelvecchio
|CapitoloPrecedente=La capinera
|NomePaginaCapitoloPrecedente=I Canti di Castelvecchio/La capinera
|CapitoloSuccessivo=Canzone di marzo
|NomePaginaCapitoloSuccessivo=I Canti di Castelvecchio/Canzone di marzo

}}'''
   cp=find_stringa(capitolo,"CapitoloPrecedente=","\n")
   ncp=find_stringa(capitolo,"NomePaginaCapitoloPrecedente=","\n")
   cs=find_stringa(capitolo,"CapitoloSuccessivo=","\n")
   ncs=find_stringa(capitolo,"NomePaginaCapitoloSuccessivo=","\n")
   
   testo=testo.replace("{{includiIntestazione","{{IncludiIntestazione")
   includiIntestazione=find_stringa(testo,"{{IncludiIntestazione","}}",1).replace(" =","=")
   inclnew=includiIntestazione
   if not "prec=" in includiIntestazione:
      inclnew=includiIntestazione.replace("}}","|prec="+ncp+"}}")
   if not "succ=" in includiIntestazione:
      inclnew=inclnew.replace("}}","|succ="+ncs+"}}")
   testo=testo.replace(includiIntestazione,inclnew)
   #print cp,ncp,cs,ncs
   #print testo
   return testo
      

def rcSession():
    '''legge recentchanges e produce una lista delle pagine nuove o editate

    La lettura si ferma all'edit con timestamp memorizzato in rcend.txt'''
    rcFinale=open("rcend.txt").read()
    lTitoli=[]
    lPagine=[]
    fineSerie=False
    rcIniziale=rc(number=1)[0][1]
    if rcFinale==rcIniziale:
      print "Nessuna attività nell'intervallo"
      return
    rcIn=rcIniziale
    while fineSerie==False:
      print "Leggo 50 elementi..."
      print rcIn
      lista=rc(number=50,rcstart=rcIn)
      rcIn=lista[len(lista)-1][1]
      print "Analizzo gli elementi..."
      for i in lista:
         if i[1] == rcFinale:
              fineSerie=True
              print "Trovato l'edit finale: procedo"
              break
              
         if i[0].title() in lTitoli:
             continue
         
         lTitoli.append(i[0].title())
         lPagine.append(i)
         if len(lTitoli)>1000:
            fineSerie=True
            print "Raggiunto il massimo  di pagine previsto: procedo"
            break
    print "Elaboro le pagine..."
    print "Estraggo la lista indici"
    lIndici=listaIndici(lPagine)

    for i in lPagine:
        if not i[0].namespace()==110: #indice
            elabora(i[0]) # fai qualcosa
    for i in lIndici:
        pag=wikipedia.Page("it",i)
        elabora(pag)
        

    print "Salvo il timestamp per la successiva sessione..."

    open("rcend.txt","w").write(rcIniziale)
    return

def listaIndici(listaPages):
    lIndici=[]
    for el in listaPages:
        i=el[0]
        if i.namespace()==110:
            if not i.title() in lIndici:
                lIndici.append(i.title())
        elif i.namespace()==108:
            titolo="Indice:"+find_stringa(i.title(),"Pagina:","/")
            if titolo.endswith(".djvu") or titolo.endswith(".pdf"):

        #print titolo
                if not titolo in lIndici:
                    lIndici.append(titolo)
    return lIndici

def elabora(pagina): # elemento è un oggetto pagina
    if pagina.isRedirectPage():
        return
    #print pagina,pagina.namespace()
    try:
        testoPagina = pagina.get() # Taking the text of the page
    except wikipedia.NoPage: # First except, prevent empty pages
        testoPagina = ''
        print "Pagina non esistente"
        return

    testoPaginaCorretto=testoPagina
    print "Su: ",pagina.title().encode("utf-8")," (namespace ",pagina.namespace(),")"
   
    if pagina.namespace()==108: # Ns pagina


        print "Apostrofi, ",
        testoPaginaCorretto=correggiApostrofi(testoPagina,pagina.title())

        print "infotesto, ",
        verificaInfotesto(pagina)

        print "AutoreCitato, ",
        testoPaginaCorretto=normalizzaAcPagina(testoPaginaCorretto)

        print "sections, ",
        testoPaginaCorretto=addSectionTagEngine(testoPaginaCorretto)

    


    if pagina.namespace()==0: # principale:
        print "Apostrofi, ",
        testoPaginaCorretto=correggiApostrofi(testoPagina,pagina.title())

        print "infotesto, ",
        verificaInfotesto(pagina)

        print "AutoreCitato, ",
        testoPaginaCorretto=normalizzaAcPagina(testoPaginaCorretto)
        print "conteggio pagine, ",
        testoPaginaCorretto=conteggioPagine(testoPaginaCorretto)

        print u"Qualità",
        testoPaginaCorretto=aggiungiQualita(testoPaginaCorretto)

        print "capitolo",
        testoPaginaCorretto=accoppaCapitolo(testoPaginaCorretto)

        print "tag pages/pagina"
        testoPaginaCorretto=accoppaPagina(testoPaginaCorretto)
      
    if pagina.namespace()==102: # Autore:
        print "Verifico dati",
        testAutore(pagina)

    if pagina.namespace()==110: # Indice:
        print "Verifico ",
        print u"qualità Indice"
        testoPaginaCorretto=aggiornaSalIndice(pagina.title(),testoPaginaCorretto)


    if testoPaginaCorretto!=testoPagina:
        print "Correzione"
        scrivi_pagina(testoPaginaCorretto,False,pagina.title(),commento="Correzione pagina via bot")
    return

##def qualIndice(testoPagina):
##    qd="25%"
##    qcorr=""
##    qual=find_stringa(testoPagina,u"{{Qualità|","}}",1)
##    if qual!="":
##        qcorr=find_stringa(qual,"|avz=","|")
##        testoPagina=testoPagina.replace(qual,"")
##    qcorrnew=find_stringa(testoPagina,u"|Qualità=","\n")
##    if qcorrnew=="":
##        if qcorr!="" and qcorr in ["25%","50%","75%","100%"]:
##            qcorr=qcorr
##        else:
##            qcorr=qd
##    testoPagina=testoPagina.replace(u"|Qualità=",u"|Qualità="+qcorr)
##    return testoPagina
        
        

    
def correggiApostrofi(testoPagina,nomePagina):
   if testoPagina.count("[[") != testoPagina.count("]]"):
      open("dati/errori.txt","a").write("\nSbilanciamento quadre in: "+nomePagina.encode("utf-8"))
      return testoPagina
   if testoPagina.count("{{") != testoPagina.count("}}"):
      open("dati/errori.txt","a").write("\nSbilanciamento graffe in: "+nomePagina.encode("utf-8"))
      return testoPagina
   if testoPagina.count("<") != testoPagina.count(">"):
      open("dati/errori.txt","a").write("\nSbilanciamento <> in: "+nomePagina.encode("utf-8"))
      return testoPagina
   tp=apos(testoPagina)
   tp=tp.replace("{{dot}}",u"·").replace("{{Dot}}",u"·")
   return tp

def conteggioPagine(testoPagina):
   tp=testoPagina
   if not "[[" in testoPagina:
      tp=testoPagina+"\n{{Conteggio pagine|[[Speciale:Statistiche]]}}"
   return tp
      
def verificaInfotesto(pagina):
   paginaDiscussione=pagina.toggleTalkPage()
   talkTesto=leggi_pagina(paginaDiscussione.title())
   if talkTesto=="": # la pagina discussione non esiste
      if pagina.namespace()==0: # ns0
         if "/" in pagina.title(): # sottopagina
            scrivi_pagina("{{IncludiInfotesto}}",False,paginaDiscussione.title(),commento="Aggiunta pagina discussione con IncludiInfotesto")
            print "Aggiunto infotesto a ",paginaDiscussione.title()
                     
      elif pagina.namespace() == 108: # ns Pagina
         scrivi_pagina("{{IncludiInfotesto}}",False,paginaDiscussione.title(),commento="Aggiunta pagina discussione con IncludiInfotesto")
         print "Aggiunto infotesto a ",paginaDiscussione.title()
   return

def apos(p=""):
    if p=="":

        p='''prova ''test'' <test1> prova' test {{test2<br />}} prova test
<test1> prova test [[test3' {{test2' <br />}} ]]
prova [test4] prova' http://www.alex'.com prova '''
    lista=[]
    p1=p[:]
    ne=0
    l=produci_lista(p1,u"<math>",u"</math>",1)
    for r in l:
        if not r in lista:
            el="#e"+str(ne)+"#"
            lista.append((r,el))
            p1=p1.replace(r,el)
            ne=ne+1
            #print "math",ne,

    #print
    l=produci_lista(p1,u"{{{",u"}}}",1)
    for r in l:
        if not r in lista:
            el="#e"+str(ne)+"#"
            lista.append((r,el))
            p1=p1.replace(r,el)
            ne=ne+1
            #print "templ",ne,
    #print
    l=produci_lista(p1,u"<",u">",1)
    for r in l:
        if not r in lista:
            el="#e"+str(ne)+"#"
            lista.append((r,el))
            p1=p1.replace(r,el)
            ne=ne+1
            #print "html",ne,
    #print "<>"
    l=produci_lista(p1,u"[[",u"]]",1)
    for r in l:
        if not r in lista:
            el="#e"+str(ne)+"#"
            lista.append((r,el))
            p1=p1.replace(r,el)
            ne=ne+1
            #print "wlink",ne,
    #print "[[]]"
            
    l=produci_lista(p1,u"[",u"]",1)
    for r in l:
        if not r in lista:
            el="#e"+str(ne)+"#"
            lista.append((r,el))
            p1=p1.replace(r,el)
            ne=ne+1
            #print "link1",ne,
    #print "[]"
    l=produci_lista(p1,u"http://",u" ",1)
    for r in l:
        if not r in lista:
            el="#e"+str(ne)+"#"
            lista.append((r,el))
            p1=p1.replace(r,el)
            ne=ne+1
            #print "link2",ne,
    #print "http:"
    l=produci_lista(p1,u"{{",u"}}",1)
    for r in l:
        if not r in lista:
            el="#e"+str(ne)+"#"
            lista.append((r,el))
            p1=p1.replace(r,el)
            ne=ne+1
            #print "templ",ne,
    #print u"{{}}"
    #return p1
    if "'''" in p1:
        p1=p1.replace("'''","#ebold#")
        lista.append(("'''","#ebold#"))
    if "''" in p1:
        p1=p1.replace("''","#eitalic#")
        lista.append(("''","#eitalic#"))
    if not "'" in p1:
        #non vi sono apostrofi tipografici nel testo modificabile,
        #la stringa viene restituita immutata
        return p                  
    #qui modificare p1
    
    p1=p1.replace(u"'",u"’")
##    p1=p1.replace(u"’’’",u"'''")
##    p1=p1.replace(u"’’",u"''")

    lista.reverse()
    p2=p1[:]
    for r in lista:
        p2=p2.replace(r[1],r[0])
        #print r[1],r[0]

    return p2

# estrai lista pagine di un ns (default:102, Autore)
def listaPagine(ns=102,includeredirects=False):
   lista=[]
   lpg=pagegenerators.AllpagesPageGenerator(namespace=102,includeredirects=includeredirects)
   for i in lpg:
      lista.append(i)
   return lista
   
def templateR(ini=79,fin=85,test=False,versoIniziale=0,basePagina="Pagina:Canti (Sole).pdf/xxx"):
   
   nv=versoIniziale
   if nv>0:
      versi=True
   else:
      versi=False
   spaziatura={}
   cancella=False
   for i in range(ini,fin):
      nomePagina=basePagina.replace("xxx",str(i))
      testoPagina=leggi_pagina(nomePagina)
      testoPagina=testoPagina.replace("<!-- no verso-->","<!-- no verso -->")
      rigaPagina=testoPagina.split("\n")
      versiPagina=rigaPagina[:]
      for i in range(len(versiPagina)):
         versiPagina[i]=""
      # algoritmo riconoscimento versi
      for r in range(len(versiPagina)):
         if "<!-- schema" in rigaPagina[r]:
            sch=find_stringa(rigaPagina[r],"<!-- schema","-->").split(";")
            for i in sch:
               el=i.split(":")
               if len(el)==1:
                  spaziatura["l"]=eval(el[0])
               else:
                  spaziatura[eval(el[0])]=eval(el[1])
            print spaziatura
            
         if not versi:
##            if "<!-- inizio versi -->" in rigaPagina[r].lower():
##               
##               versi=True
            if "<!-- inizio poesia -->" in rigaPagina[r].lower():
               cancella=True
               versi=True
               versiPagina[r]="*"
            else:
               continue

         if versi:
            if cancella:
               rigaPagina[r]=rigaPagina[r].lstrip()
               rigaPagina[r]=rigaPagina[r].replace(find_stringa(rigaPagina[r],"{{R|","}}",1),"")
            rp=rigaPagina[r].replace("<poem>","").replace("</poem>","")
            rp=rp.replace("<noinclude>","").replace("</noinclude>","")
            rp=rp.strip()
            
            if rp==u"":
               continue
            elif "<!-- no verso -->" in rigaPagina[r].lower():
               continue
            elif "{{centrato" in rigaPagina[r].lower():
               continue
            elif "pagequality" in rigaPagina[r].lower():
               continue
            elif "references" in rigaPagina[r].lower():
               continue
            else:
               versiPagina[r]+="*"
               if "<!-- fine versi -->" in rigaPagina[r].lower():
                  versi=False
      for r in range(len(versiPagina)):
         if versiPagina[r]=="**":
            nv=1
            if "l" in spaziatura and (nv-1) % spaziatura["l"] in spaziatura:
               rigaPagina[r]=" "*spaziatura[(nv-1) % spaziatura["l"]]+rigaPagina[r].lstrip()
         elif versiPagina[r]=="*":
            nv=nv+1
            if "l" in spaziatura and (nv-1) % spaziatura["l"] in spaziatura:
               rigaPagina[r]=" "*spaziatura[(nv-1) % spaziatura["l"]]+rigaPagina[r].lstrip()
            if nv % 5 ==0:
               if "</poem>" in rigaPagina[r]:
                  rigaPagina[r]=rigaPagina[r].replace("</poem>","{{R|##}}".replace("##",str(nv)))
               else:
                  rigaPagina[r]=rigaPagina[r].rstrip()+"{{R|##}}".replace("##",str(nv))
         print versiPagina[r],rigaPagina[r]
      testoPagina="\n".join(rigaPagina)
      testoPagina=testoPagina.replace("<!-- inizio poesia -->","")\
.replace("<!-- inizio versi -->","").replace("<!-- fine versi -->","")
      #print testoPagina
      if not test:
         scrivi_pagina(testoPagina,False,nomePagina)
   return
         
         
              
            

def correggiPoem(pagina):
   testoPagina=leggi_pagina(pagina)
   testoPagina=testoPagina.replace("<poem> \n","<poem>").replace("\n</poem>","</poem>")
   scrivi_pagina(testoPagina,False,pagina,commento="Normalizzazione tag poem via bot")
   return

def chiamaCorreggiPoem(basePagina):
   numeroPagina=1
   while True:
      pagina=basePagina+str(numeroPagina)
      testoPagina=leggi_pagina(pagina)
      if testoPagina=="":
         print "Fine controllo"
      if "<poem> \n" in testoPagina or "\n</poem>"in testoPagina:
         correggiPoem(pagina)
         numeroPagina+=1
      else :
         print "Pagina", pagina, "non contiene tag poem"
         numeroPagina+=1
         
   return
   
      
   
def aggiungiQualita(testo):
    if not u"{{Qualità" in testo:
        testo=u"{{Qualità|avz=25%|data=|arg=Da definire}}"+testo
    return testo
   
   
   
def correggiSAL():
   lista=produci_lista(leggi_pagina("Wikisource:Pagina delle prove"),"{{testo|","}}")
   for i in lista:
      if "Sonetti romaneschi" in i:
         testo=leggi_pagina(i)
         testo=testo.replace(find_stringa(testo,u"{{Qualità|avz=25%|","}}",1),"")
         scrivi_pagina(testo,False,i)
   return 
                       
def caricaLibro(folder="dati/bemcav", baseFile="bemcavalgar-singlepages - ", \
                zf=4, basePagina=u"Página:Bem cavalgar (1842).djvu/#", ini=1,fin=1,poem=False,code="pt"):
   base=u'<noinclude><pagequality level="1" user="Alebot" /><div class="pagetext">\n\n\n</noinclude>#<noinclude>\n<references/></div></noinclude>'
   for pag in range(ini,fin+1):
      pagina=open(folder+"/"+baseFile+str(pag).zfill(zf)+".txt").read()
      pagina=unicode(pagina,"utf-8")
      if poem:
         pagina="<poem> \n"+pagina+"</poem>"
      nomePagina=basePagina.replace("#",str(pag))
      if leggi_pagina(nomePagina)!="":
         pagina=base.replace("#",pagina)
      scrivi_pagina(pagina,False,nomePagina, commento="External upload/edit by unflagged bot",code=code)
      
   return

def recentchanges(number = 200, rcstart = None, rcdir="newer",
      rcend = None, rcshow = None, rctype ='edit|new', namespace="0|102|108|110", 
      includeredirects=False, repeat = False):
   # chiama il metodo recentchanges() di wikipedia.Site()
   # produce un generatore che restituisce la seguente tuple di esempio:
   # (Page{[[Poema paradisiaco/Hortus Larvarum]]}, u'2010-04-25T08:23:24Z',
   # u'LloydApplebaum', u'Porto il SAL a SAL 75%', '')
   # ossia: page, i['timestamp'], i['user'], comment, loginfo
   
   rcstart=carica_pcl("rcstart")
      
   """def recentchanges(self, number = 100, rcstart = None,
      rcend = None, rcshow = None, rctype ='edit|new', namespace=None,
      includeredirects=True, repeat = False):
        
        Yield ImagePages from APIs, call: action=query&list=recentchanges&rctype=edit|new&rclimit=500

        Options directly from APIs:
        ---
        Parameters:
          rcstart        - The timestamp to start enumerating from.
          rcend          - The timestamp to end enumerating.
          rcdir          - In which direction to enumerate.
                           One value: newer, older
                           Default: older
          rcnamespace    - Filter log entries to only this namespace(s)
                           Values (separate with '|'):
                           0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
          rcprop         - Include additional pieces of information
                           Values (separate with '|'):
                           user, comment, flags, timestamp, title, ids, sizes,
                           redirect, patrolled, loginfo
                           Default: title|timestamp|ids
          rctoken        - Which tokens to obtain for each change
                           Values (separate with '|'): patrol
          rcshow         - Show only items that meet this criteria.
                           For example, to see only minor edits done by
                           logged-in users, set show=minor|!anon
                           Values (separate with '|'):
                           minor, !minor, bot, !bot, anon, !anon,
                           redirect, !redirect, patrolled, !patrolled
          rclimit        - How many total changes to return.
                           No more than 500 (5000 for bots) allowed.
                           Default: 10
          rctype         - Which types of changes to show.
                           Values (separate with '|'): edit, new, log"""
   source=wikipedia.Site("it")
   rctype="new"
   tnew=t
   tedit=t
   pagineRecentiNuove=source.recentchanges(number, rcstart , rcend,  rcshow, rcdir,  rctype, namespace, includeredirects, repeat)
   lnew=[]
   for i in pagineRecentiNuove:
      lnew.append(i)
   if len(lnew)>0:
      tnew=lnew[len(lnew)-1][1]
   rctype="edit"
   rcshow="!bot|!redirect"
   pagineRecentiEdit=source.recentchanges(number, rcstart , rcend,  rcshow, rcdir,  rctype , namespace, includeredirects, repeat)
   ledit=[]
   for i in pagineRecentiEdit:
      ledit.append(i)
   if len(ledit)>0:
      tedit=ledit[len(ledit)-1][1]
   salva_pcl(max(tnew,tedit),"rcstart")
      
   return lnew,ledit



   
           
         
      
   
def listaCapitoli(pagina,doElabora=False): #pagina è il nome di una pagina o sottopagina Ns0
   if "/" in pagina:
      pagina=find_stringa("##"+pagina,"##","/")
   pag=leggi_pagina(pagina)
   pag=pag.replace("{{Testo","{{testo")
   lista=produci_lista(pag, "{{testo|","}}")
   for i in range(len(lista)):
      if "|" in lista[i]:
         lista[i]=lista[i][:lista[i].find("|")]
      if lista[i].startswith("/"):
         lista[i]=pagina+lista[i]
   if doElabora:
      for i in lista:
         oggettoPagina=wikipedia.Page("it",i)
         elabora(oggettoPagina)
   return lista

   
      

def rs(elenco):
   for i in elenco:
      rivediSottopagine(i)
   return

def rivediSottopagine(pagina,commento="Correzione tag poem"):
   pag=leggi_pagina(pagina)
   pag=pag.replace("{{Testo","{{testo")
   lista=produci_lista(pag, "{{testo|","}}")
   for i in range(len(lista)):
      if "|" in lista[i]:
         lista[i]=lista[i][:lista[i].find("|")]
      if lista[i].startswith("/"):
         lista[i]=pagina+lista[i]
   for sottopagina in lista:
      testo=leggi_pagina(sottopagina)
      if testo>"":
         # azione da fare sulle sottopagine
         testo1=modifica(testo,sottopagina)
         if testo1!=testo:
            scrivi_pagina(testo1,False,sottopagina,commento=commento)
   
         
         
   return 

def modifica(testo,sottopagina):
   if "<poem>\n" in testo:
      testo=testo.replace("<poem>\n","<poem> \n")
   else:
      print sottopagina,"OK"
   # altre azioni...
   return testo


def nuovePagineTest():
   np=[]
   npag=pagegenerators.NewpagesPageGenerator(number=10,namespace=0)
   for i in npag:
      np.append(i)
   return np

schemaDatiAutore='''
<includeonly>{{{{{2|Autore}}}
 0   | Nome ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|1}}
 1   | Cognome ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|2}}
 2   | Iniziale del cognome ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|3}}
 3   | Eventuale altro nome ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|4}}
 4   | Eventuale pseudonimo ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|5}}
 5   | Eventuale nome reale ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|6}}
 6   | Giorno e mese di nascita ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|7}}
 7   | Anno di nascita ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|8}}
 8   | Giorno e mese di morte ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|9}}
 9   | Anno di morte ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|10}}
 10   | Secolo di attività ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|11}}
 11   | Eventuale secondo secolo di attività ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|12}}
 12   | Professione e nazionalità ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|13}}
 13   | Nome della pagina su Wikipedia ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|14}}
 14   | Nome della pagina su Wikiquote ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|15}}
 15   | Nome della pagina su Wikinotizie ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|16}}
 16   | Nome della pagina su Commons ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|17}}
 17   | Nome dell'immagine ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|18}}
 18   | Vuoi l'indice dei contenuti? ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|19}}
 19   | Abbiamo testi scritti dall'autore? ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|20}}
 20   | Abbiamo traduzioni scritte dall'autore? ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|21}}
 21   | L'autore è citato in altre opere pubblicate? ={{#titleparts:{{#section:Autore:{{{1|Giacomo Leopardi}}}|dati}}|1|22}}
    }}</includeonly>'''



class Autore(wikipedia.Page): # Acquisisce tutti i metodi di Site
   def __init__(self, pagina):      # nota: pagina è già un'istanza di Page, me la passa pagegenerators.py
      self.testo=pagina.get()       # e infatti, i suoi  metodi funzionano, compreso get
      if "{{Autore" in self.testo:
         self.intestazione=find_stringa(self.testo,"{{Autore","}}",1)   # find_stringa è una funzione mia (la mia prediletta...)
                                                                                            # fa una cosetta che con le regex si impazzirebbe.... almeno io.
      else:
         self.intestazione=find_stringa(self.testo,"{{autore","}}",1)
      intStandard=self.intestazione.replace("| ","|").replace(" =","=") # una sistemata a eventuali varianti di spazi
      self.intStandard=intStandard                                                                # questo è un  print di debug
      self.page=pagina
      self.nome=find_stringa(intStandard,u"|Nome=","\n").strip()
      self.cognome=find_stringa(intStandard,u"|Cognome=","\n").strip()
      self.iniziale=find_stringa(intStandard,u"|Iniziale del cognome=","\n").strip()
      self.altro_nome=find_stringa(intStandard,u"|Eventuale altro nome=","\n").strip()
      self.pseudonimo=find_stringa(intStandard,u"|Eventuale pseudonimo=","\n").strip()
      self.nome_reale=find_stringa(intStandard,u"|Eventuale nome reale=","\n").strip()
      self.gm_nascita=find_stringa(intStandard,u"|Giorno e mese di nascita=","\n").strip()
      self.a_nascita=find_stringa(intStandard,u"|Anno di nascita=","\n").strip()
      self.gm_morte=find_stringa(intStandard,u"|Giorno e mese di morte=","\n").strip()
      self.a_morte=find_stringa(intStandard,u"|Anno di morte=","\n").strip()
      self.secolo=find_stringa(intStandard,u"|Secolo di attività=","\n").strip()
      self.secolo2=find_stringa(intStandard,u"|Eventuale secondo secolo di attività=","\n").strip()
      self.prof_naz=find_stringa(intStandard,u"|Professione e nazionalità=","\n").strip()
      self.wikipedia,self.wikiquote,self.wikinotizie,self.commons,self.immagine="","","","",""
      if find_stringa(intStandard,u"|Nome della pagina su Wikipedia=","\n").strip()!="":
         self.wikipedia="x"
      if find_stringa(intStandard,u"|Nome della pagina su Wikiquote=","\n").strip()!="":
         self.wikiquote="x"
      if find_stringa(intStandard,u"|Nome della pagina su Wikinotizie=","\n").strip()!="":
         self.wikinotizie="x"
      if find_stringa(intStandard,u"|Nome della pagina su Commons=","\n").strip()!="":
         self.commons="x"
      if find_stringa(intStandard,u"|Nome dell'immagine=","\n").strip()!="":
         self.immagine="x"
      self.indice=find_stringa(intStandard,u"|Vuoi l'indice dei contenuti?=","\n").strip()         
      self.testi=find_stringa(intStandard,u"|Abbiamo testi scritti dall'autore?=","\n").strip()
      self.traduzioni=find_stringa(intStandard,u"|Abbiamo traduzioni scritte dall'autore?=","\n").strip()
      self.citazioni=find_stringa(intStandard,u"|L'autore è citato in altre opere pubblicate?=","\n").strip()
      self.dati="<!--non modificare da qui:--><includeonly><section begin=dati />"+\
self.nome+"/"+self.cognome+"/"+self.iniziale+"/"+self.altro_nome+"/"+self.pseudonimo+"/"+\
self.nome_reale+"/"+self.gm_nascita+"/"+self.a_nascita+"/"+\
self.gm_morte+"/"+self.a_morte+"/"+self.secolo+"/"+self.secolo2+"/"+self.prof_naz+"/"+\
self.wikipedia+"/"+self.wikiquote+"/"+self.wikinotizie+"/"+self.commons+"/"+\
self.immagine+"/"+self.indice+"/"+self.testi+"/"+self.traduzioni+"/"+self.citazioni+\
"<section end=dati /></includeonly><!-- a qui-->\n"
   def autore_per_indici(self): # usa nome,cognome,gm_nascita,a_nascita,gm_morte,a_morte,prof_naz
      riga="<tr><td>'''''[[Autore:"+self.nome
      if self.cognome!="":
         riga+="_"+self.cognome
      riga+="|"
      if self.cognome=="":
         riga+=self.nome
      else:
         riga+=self.cognome+",&nbsp;"+self.nome
      riga+="]]'''''</td>"
      if self.a_nascita=="":
         if self.a_morte=="":
            if self.secolo=="":
               riga+="<td>&nbsp;</td>"
            else:
               riga+="<td>"+self.secolo+"</td>"
         else:
            if self.gm_morte=="":
               riga+=u"<td>????&nbsp;–&nbsp;"+self.a_morte+"</td>"
            else:
               riga+=u"<td>????&nbsp;–&nbsp;{{DataGiorno|"+self.gm_morte+"}}&nbsp;"+self.a_morte+"</td>"
      else:
         if self.a_morte=="":
            if self.gm_nascita=="":
               riga+="<td>"+self.a_nascita+u"&nbsp;–&nbsp;...</td>"
            else:
               riga+="{{DataGiorno|"+self.gm_nascita+u"}}&nbsp;"+self.a_nascita+u"&nbsp;–&nbsp;...</td>"
         else:
            if self.gm_morte=="":
               if self.gm_nascita=="":
                  riga+="<td>"+self.a_nascita+u"&nbsp;–&nbsp;"+self.a_morte+"</td>"
               else:
                  riga+="<td>{{DataGiorno|"+self.gm_nascita+"}}&nbsp;"+self.a_nascita+u"&nbsp;–&nbsp;"+self.a_morte+"</td>"
            else:
               if self.gm_nascita=="":
                  riga+="<td>"+self.a_nascita+u"&nbsp;–&nbsp;{{DataGiorno|"+self.gm_morte+u"}}&nbsp;"+self.a_morte+"</td>"
               else:
                  riga+="<td>{{DataGiorno|"+self.gm_nascita+"}}&nbsp;"+self.a_nascita+\
                     u"&nbsp;–&nbsp;{{DataGiorno|"+self.gm_morte+"}}&nbsp;"+self.a_morte+"</td>"
      if self.prof_naz=="":
         riga+=u"<td>&nbsp;</td>"
      else:
         riga+="<td>{{lcfirst:"+self.prof_naz+"}}</td>"
      riga+="</tr>"
      return riga
   def autore_per_indici_new(self): # usa nome,cognome,gm_nascita,a_nascita,gm_morte,a_morte,prof_naz
      riga="<tr><td>'''''[[Autore:"+self.nome
      if self.cognome!="":
         riga+="_"+self.cognome
      riga+="|"
      if self.cognome=="":
         riga+=self.nome
      else:
         riga+=self.cognome+",&nbsp;"+self.nome
      riga+="]]'''''</td>" # cella 1
      if self.gm_nascita!="":
         riga+="<td>[[Wikisource:Ricorrenze/"+self.gm_nascita+"|"+ self.gm_nascita+"]]</td>"
      else:
         riga+="<td>&nbsp;</td>"
      if self.a_nascita!="":
         riga+="<td>"+self.a_nascita+"</td>"
      else:
         riga+="<td>&nbsp;</td>"
      if self.gm_morte!="":
         riga+="<td>[[Wikisource:Ricorrenze/"+self.gm_morte+"|"+ self.gm_morte+"]]</td>"
      else:
         riga+="<td>&nbsp;</td>"
      if self.a_nascita!="":
         riga+="<td>"+self.a_morte+"</td>"
      else:
         riga+="<td>&nbsp;</td>"
      if self.a_nascita!="":
         riga+="<td>"+self.secolo+"</td>"
      else:
         riga+="<td>&nbsp;</td>"
      if self.prof_naz!="":
         riga+="<td>"+self.prof_naz+"</td></tr>\n"
      else:
         riga+="<td>&nbsp;</td></tr>\n"
      return riga


def ritorna():
   return



   

def leggiNuovePagine(lnew,ledit):
   for ns in ["Autore","Principale","Pagina","Indice"]: # :["Pagina"]
      #np=nuovePagine(nPag=200, ns=ns, repeat=False)
      np=[]
      for i in lnew:
         if i[0].namespace()==wnamespaces[ns]:
            np.append(i[0])
            
      if len(np)>0:
         azioniNuovePagine(np,ns)
         
      else:
         print "Nessuna nuova pagina ", ns
##      ep=[]
##      for i in ledit:
##         if i[0].namespace()==wnamespaces[ns]:
##            ep.append(i[0])
##            
##      if len(np)>0:
##         azioniPagineEditate(ep,ns)
##         
##      else:
##         print "Nessuna pagina editata", ns
##         
   print "Numero delle pagine editate: ", len(ledit)
   return

def azioniNuovePagine(np,ns):
   print "Nuove pagine ",len(np)
   for i in np:

      print i.title()
      if ns=="Pagina":
         titleDiscussione=i.title().replace("Pagina:","Discussioni pagina:")
         print titleDiscussione
         if leggi_pagina(titleDiscussione)=="":
            scrivi_pagina("{{IncludiInfotesto}}",False,titleDiscussione,commento="Aggiunta tl IncludiInfotesto via bot")
      elif ns=="Principale":
         if not "/" in i.title():
            testo=i.get().replace("{{Raccolta","{{raccolta")
            raccolta=find_stringa(testo,"{{raccolta|","}}")
            #print raccolta
            if not raccolta=="":
            
               if leggi_pagina("Discussione:"+raccolta) != "":
                  pagDiscussione="Discussione:"+i.title()
                  if leggi_pagina(pagDiscussione) == "":
                  #print "Scriverò su", pagDiscussione, "{{Discussione:"+raccolta+"}}"
                     scrivi_pagina("{{Discussione:"+raccolta+"}}",False,pagDiscussione)
                  else:
                     print pagDiscussione, "esistente"
   return

def azioniPagineEditate(np,ns):
   print "Pagine editate ",len(np)
   for i in np:

      print i.title()

      if ns=="Pagina" or ns=="Principale":
         testoPagina=i.get()
         tp=apos(testoPagina)
         if tp != testoPagina:
            scrivi_pagina(tp,False,i.title(),commento="Correzione apostrofi via bot")
   return
               
                  

def nuovePagine(nPag=200, ns="Autore",repeat=False):
    nsn=wnamespaces[ns]
    #NewpagesPageGenerator(number = 100, get_redirect = False, repeat = False, site = None, namespace = 0):
    npag=pagegenerators.NewpagesPageGenerator(number=nPag,namespace=nsn)
    vecchiePagine=carica_pcl("nuove"+ns)
    nuovePagine=[]
    np=set('')
    for i in npag:
        if not i.title() in vecchiePagine:
            np.add(i)
            nuovePagine.append(i.title())
    if len(nuovePagine)>0:
        vecchiePagine=vecchiePagine+nuovePagine
        if len(vecchiePagine)>500:
            vecchiePagine=vecchiePagine[-500:]
        salva_pcl(vecchiePagine, "nuove"+ns)
        print "Salvato nuovo elenco ","nuove"+ns, "di",len(vecchiePagine),"elementi"
        
    return np

def richieste_bot():
    pr=list_in_cat("Bot calls")
    print pr
    if len(pr)>0:
        pagina=pr[0]
        testo_pagina=leggi_pagina(pagina)
        richiesta=find_stringa(testo_pagina,"{{ToAlebot","}}",1)
        #testo_pagina=testo_pagina.replace(richiesta,"")
        #scrivi_pagina(testo_pagina,False,pagina)
        risultato=esegui_richiesta(richiesta,pagina)
        print "Richiesta eseguita"
    else:
        print "Nessuna richiesta pendente"
    return 

def esegui_richiesta(richiesta,pagina_richiesta):
    r=find_stringa(richiesta,"{{ToAlebot","}}").split("|")
    r_user=""
    r_page=""
    
    for i in range(len(r)):
        if r[i].lower().startswith("user="):
            r_user=r[i]
        if r[i].lower().startswith("page="):
            r_page=r[i]
    rx=r[:]
    r=[]
    for i in rx:
        if i!= r_user and i!=r_page:
            r.append(i)
    print "Richiesta da eseguire:",r[0]

    ## routine intersection
    if r[0].lower()=="intersection":
        intersection(richiesta,pagina_richiesta,r,r_user,r_page)
    elif r[0].lower()=="agginfotesto":
        aggiungiInfotesto(richiesta,pagina_richiesta,r, r_user,r_page)
    else:
        print "Richiesta non comprensibile"

    return

def aggiungiInfotesto(richiesta,pagina_richiesta,r, r_user,r_page):
    aggInfotesto()
    testoPaginaRichiesta=leggi_pagina(pagina_richiesta).replace(richiesta,"")
    scrivi_pagina(testoPaginaRichiesta,False,pagina_richiesta, commento="Cancellata la richiesta ToAlebot via bot")
    
    return

def aggInfotesto():
    lista=list_in_cat("Pagine senza pagina di discussione")
    print "Numero pagine: ",len(lista)
    for i in lista:
        #print i
        if "/" in i:
            testoDiscussione=leggi_pagina("Discussione:"+i)
            testoPagina=leggi_pagina(i)
            
            if testoDiscussione=="":
                scrivi_pagina("{{IncludiInfotesto}}",False,"Discussione:"+i,commento="Aggiunto tl IncludiInfoTesto via bot")
            
            if not "[[" in testoPagina:
                scrivi_pagina("\n{{Conteggio pagine|[[Speciale:Statistiche]]}}",True,i,commento="Aggiunto tl ConteggioPagine via bot")
            elif testoDiscussione !="":
                scrivi_pagina(testoPagina, False,i,commento="Forzatura aggiornamento Categoria")
    return

def intersection(richiesta,pagina_richiesta,r, r_user,r_page):
    print r
    lista='''\n===Risultato query: intersezione categorie===\nDalla intersezione di '''
    info=r[1:]
    for i in range(len(info)):
        info[i]=" '''"+info[i]+"''' "
    lista+="&".join(info)
    lista+= "\nrisulta il seguente elenco di pagine:\n"
    lista_pagine=query(r)
    for i in lista_pagine:
        lista+="* {{testo|"+i+"}}\n"
    if r_page=="":
        pagina_risposta="Wikisource:Pagina delle prove"
    if pagina_risposta==pagina_richiesta:
        testoPaginaRisposta=leggi_pagina(pagina_richiesta).replace(richiesta,lista)
        #print testoPaginaRisposta
        scrivi_pagina(testoPaginaRisposta,False,pagina_risposta,commento="Scrittura risposta query intersection via bot")
    else:
        print "pagina risposta:",pagina_risposta
        scrivi_pagina(lista,True,pagina_risposta,commento="Scrittura risposta query intersection via bot")
        testoPaginaRichiesta=leggi_pagina(pagina_richiesta).replace(richiesta,"")
        scrivi_pagina(testoPaginaRichiesta,False,pagina_richiesta,commento="Cancellazione richiesta query intersection via bot")
    return

def query(r):
    print r
    l=set(list_in_cat(r[1])) # estrazione dati prima categoria
    print r[1], len(l)
    for i in range(2,len(r)): # estrazione dati altre categorie e intersezione con la prima
        c=set(list_in_cat(r[i]))
        print r[i], len(c)
        l=l & c
    ls=[]
    for i in l:
        ls.append(i)
    ls.sort()
##    s=u""
##    for i in ls:
##        s=s+"* {{testo|"+i+"}}\n"
    return ls # restituisce la lista delle pagine

class MailBot:
    def __init__(self, destinationUser, subject, message, copyToMe):
        self.destinationUser = destinationUser
        self.subject = subject
        self.message = message
        self.copyToMe = copyToMe

        # valido per it.wikisource (servirebbe una lista da cui scegliere secondo wikipedia.getSite() ...)
        self.sendEmailPage = "/wiki/Speciale:InviaEMail/" 
        self.sendEmailPagePOST = "/w/index.php?title=Speciale:InviaEMail&target=%s&action=submit" 

    def run(self):
        # get any page to get token parameter
        mailToPage = wikipedia.getSite().getUrl(self.sendEmailPage + self.destinationUser)
        token=find_stringa(mailToPage,u'<input name="wpEditToken" type="hidden" value="','"')
        print token 
        if token=="":
            print "Fail: token not found"
            return

        # create post parameters
        subject = self.subject.encode(wikipedia.getSite().encoding())
        message = self.message.encode(wikipedia.getSite().encoding())
        if self.copyToMe:
            copyToMe = '1'
        else:
            copyToMe = '0'
        predata = {
            'wpSubject': subject,
            'wpText': message,
            'wpCCMe': copyToMe,
            'wpEditToken' : token
        }

        # do a post request
        postUrl = self.sendEmailPagePOST % self.destinationUser
        response, data = wikipedia.getSite().postForm(postUrl, predata)
        
        if response.status == 302: # redirect code
            print "Mail (probably) sent"
        else:
            print "Fail: http status code is %s, error reason is %s" % (str(response.status), response.reason)


def mailto(utente=u"Alex_brollo",oggetto=u"Prova invio",messaggio=u"Testo messaggio prova", cc=False ):
	bot = MailBot(utente, oggetto, messaggio, cc)
	bot.run()



def oggi():
    oggi=date.today()
    oggi=oggi.isoformat().split("-")
    print oggi
    mesi=["gennaio","febbraio","marzo","aprile","maggio","giugno", "luglio","agosto","settembre","ottobre","novembre","dicembre"]
    mese=oggi[1]
    if mese.startswith("0"):
        mese=mese[1:]
    mese=eval(mese)-1
    oggi=oggi[2] +" "+ mesi[mese] +" "+oggi[0]
    return oggi





def list_in_cat(category_name,site="it"):
    site = wikipedia.getSite()
    cat = catlib.Category(site,'Category:'+category_name)
    gen = pagegenerators.CategorizedPageGenerator(cat)
    page_list=[]
    for page in gen:
    #Do something with the page object, for example:
        page_list.append(page.title())
    return page_list

      
def sposta_pagina(nome_pagina,nuovo_nome_pagina,motivo):
    site = wikipedia.getSite()
    page = wikipedia.Page(site, nome_pagina)
    try:
        text = page.move(nuovo_nome_pagina,reason=motivo,
      throttle=False, deleteAndMove=False, safe=True, fixredirects=False, leaveRedirect=False) # Taking the text of the page
    except wikipedia.NoPage: # First except, prevent empty pages
        text = ''
    except wikipedia.IsRedirectPage: # second except, prevent redirect
        text = "#REDIRECT"
        # output(u'%s is a redirect!' % pagename)
        
    except wikipedia.Error: # third exception, take the problem and print
        output(u"Some error, skipping..")
    #wikipedia.stopme()
    return text
   
   
                      
def leggi_pagina(nome_pagina=u"Utente:Alex brollo",site="it"):
    #site = wikipedia.getSite()
    page = wikipedia.Page(site, nome_pagina)
    try:
        text = page.get() # Taking the text of the page
    except wikipedia.NoPage: # First except, prevent empty pages
        text = ''
    except wikipedia.IsRedirectPage: # second except, prevent redirect
        text = "#REDIRECT"
        # output(u'%s is a redirect!' % pagename)
        
    except wikipedia.Error: # third exception, take the problem and print
        output(u"Some error, skipping..")
    #wikipedia.stopme()
    return text
                  

# Writes into it.wikisource a unicode string into a named page (full name), adding to previous content (aggiungi=True)
# or replacing it (aggiungi=False)
def scrivi_pagina(testo="",aggiungi=True,nome_pagina="Utente:Alex brollo/Sandbox",commento="Edit by Alebot",code="it"):
    site = wikipedia.getSite(code)
    page = wikipedia.Page(site, nome_pagina)
    
    
    if aggiungi:
        contenuto = page.get()
        try:
            page.put(newtext=contenuto+u"\n\n"+testo,comment=commento,minorEdit=False)
            
        except wikipedia.LockedPage:
            return "Pagina bloccata"
    else:
        try:
            page.put(newtext=testo,comment=commento,minorEdit=False)
        except wikipedia.LockedPage:
            return "Pagina bloccata"
    wikipedia.stopme()
    return "Fatto"


def list_in_cat(category_name,site="base"):
    site = wikipedia.getSite()
    cat = catlib.Category(site,'Category:'+category_name)
    gen = pagegenerators.CategorizedPageGenerator(cat)
    page_list=[]
    for page in gen:
    #Do something with the page object, for example:
        page_list.append(page.title())
    return page_list
# Routine generiche
# dumps a variable

## General string management routines for RegEx ignorants :-(

# finds a substring beginning with idi and ending with idf; returns it
# with (dc=1) or without (default dc=0) idi and idf; used for xml managing too

def find_stringa(stringa,idi,idf,dc=0,side="left"):
    if side=="right":
        idip=stringa.rfind(idi)
    else:
        idip=stringa.find(idi)
    idfp=stringa.find(idf,idip+len(idi))+len(idf)
    if idip>-1 and idfp>0:
        if dc==0:
            vvalore=stringa[idip+len(idi):idfp-len(idf)]
        else:
            vvalore=stringa[idip:idfp]
    else:
        vvalore=""
    return vvalore

# variant; as find_stringa, but searches into stringa from offset (default 0);
# returns substring without and with delimiters, the absolute offset of the
# second delimiter, the indices of the substring (null strings if not found)

def find_next(stringa,idi,idf,offset=0):
    idip=stringa.find(idi,offset)
    idfp=stringa.find(idf,idip+len(idi))+len(idf)
    if idip>-1 and idfp>0:
        
        stringa_i=stringa[idip+len(idi):idfp-len(idf)]
        stringa_t=stringa[idip:idfp]
##        if stampa:
##            print stringa_t,
        offset=idfp-len(idf)
    else:
        stringa_i=''
        stringa_t=''
    return stringa_i,stringa_t,offset,idip,idfp

# appoggiandosi a find_next, produce una lista di tutte le istanze della
# sottostringa idi...idf, contenente per ciascun valore i dati:
# stringa_i,stringa_t,offset,idip,idfp

def find_all(stringa,idi,idf):
    lista=[]
    offset=0
    while True:
        r=find_next(stringa,idi,idf,offset)
        if r[0]!="":
            lista.append(r)
            offset=r[2]
        else:
            return lista

def find_split(stringa,idi,idf):
   ''' seziona una stringa utilizzando una sottoscringa come elemento di separazione

   la sottostringa è identificata da idi,idf; il risultato è una lista di stringhe
   analoga a quella prodotta da splitter'''
   
   result=[]
   rp=[]
   tagged=find_all(stringa,idi,idf)
##   for i in range(len(tagged)):
##      tagged[i]=[tagged[i][1],tagged[i][3],tagged[i][4]]
   #print tagged
   if len(tagged)==0: # caso nessun tagged
      result.append(stringa)
      return result
   if tagged[0][3]!=0: # caso tagged non all'inizio di pagina
      rp.append(stringa[0:tagged[0][3]])
   for i in range(len(tagged)):
      rp.append(tagged[i][1])
      if i==len(tagged)-1: # se è stato trattato l'ultimo elemento tagged
         rp.append(stringa[tagged[i][4]:]) # aggiungi il resto di stringa
         return rp
      rp.append(stringa[tagged[i][4]:tagged[i+1][3]])
   return rp

    

# restituisce la stringa idi...ifd "a cavallo" di offset
# senza (dc=0) o con (dc!=0) i delimitatori idi...idf
        
def find_r(stringa,idi,idf,offset,dc=1):
    idip=stringa.rfind(idi,0,offset)
    idfp=stringa.find(idf,idip+len(idi))+len(idf)
    if idip>-1 and idfp>0:
        if dc==0:
            vvalore=stringa[idip+len(idi):idfp-len(idf)]
        else:
            vvalore=stringa[idip:idfp]
    else:
        vvalore=""
    return vvalore
    
        
# replaces the first substring idi...idf into string with new; returns
# a tuple with whole replaced string and substring that has been removed/replaced

def el_st(stringa,idi,idf,new=""):
    idip=stringa.find(idi)
    idfp=stringa.find(idf,idip)+len(idf)
    if idip>-1 and idfp>0:
        vvalore=stringa[idip:idfp]
        valore=stringa.replace(vvalore,new,1)
    else:
        vvalore=""
        valore=stringa
    return valore, vvalore

# returns a list of all substrings (beginning with idi and ending with idf)
# of a string; ; used for xml data managing too

def produci_lista(testo,idi,idf,dc=0):
    t=testo[:]
    lista=[]
    while not find_stringa(t,idi,idf)=="":
        el=find_stringa(t,idi,idf,1)
        t=t.replace(el,"")
        #print el
        if dc==0:
            el=find_stringa(el,idi,idf,0)
        #print el
        #print
        lista.append(el)
    return lista

def produci_lista1(testo,idi,idf,dc=0):
    t=testo[:]
    lista=[]
    while not find_stringa(t,idi,idf)=="":
        el=find_stringa(t,idi,idf,1)
        t=t.replace(el,"",1)
        #print el
        if dc==0:
            el=find_stringa(el,idi,idf,0)
        #print el
        #print
        lista.append(el)
    return lista

def carica_pcl(nome_file, folder="dati/"):
    nome_file=folder+nome_file+".pcl"
    f=open(nome_file)
    contenuto=pickle.load(f)
    f.close()
    return contenuto
def salva_pcl(variabile,nome_file="dato",folder="dati/"):
    nome_file=folder+nome_file+".pcl"
    f=open(nome_file,"w")
    pickle.dump(variabile, f)
    f.close()
    return "Variabile salvata nel file "+nome_file
def imagepage(titolo): #restituisce un oggetto ImagePage da Commons
   #famiglia=wikipedia.Family("commons")
   commons=wikipedia.getSite("commons",wikipedia.Family("commons"))
   paginaImmagine=wikipedia.ImagePage(commons,titolo)
   return paginaImmagine
   
      
def leggi_pagina_html(nome_pagina=u"Utente:Alex brollo"):
    site = wikipedia.getSite()
    page = wikipedia.Page(site, nome_pagina)
    try:
        text = site.getUrl(nome_pagina) # Taking the text of the page
    except wikipedia.NoPage: # First except, prevent empty pages
        text = ''
    except wikipedia.IsRedirectPage: # second except, prevent redirect
        text = "#REDIRECT"
        # output(u'%s is a redirect!' % pagename)
        
    except wikipedia.Error: # third exception, take the problem and print
        output(u"Some error, skipping..")

    wikipedia.stopme()
    return text

def aggiornaSalIndice(nomeIndice,testoIndice): # riceve il nome di una pagina Indice e aggiorna il parametro SAL
    sal=qualitaIndice(nomeIndice)
    #testoIndice=leggi_pagina(nomeIndice)
    salPerc="25%"
    if sal==2:
        salPerc="50%"
    elif sal==3:
        salPerc="75%"
    elif sal==4:
        salPerc="100%"
    elif sal==0:
        print "Bug in azione - procedura annullata"
        return testoIndice
    qualIndice=find_stringa(testoIndice,u"|Qualità=","\n",1)
    
    qualIndiceNew=u"|Qualità="+salPerc+"\n"
    print "sal=",sal,salPerc, qualIndice,qualIndiceNew
    testoIndiceNew=testoIndice.replace(qualIndice,qualIndiceNew)
    tlQualita=find_stringa(testoIndiceNew,u"{{Qualità|","}}",1)
    if tlQualita!="":
        testoIndiceNew=testoIndiceNew.replace(tlQualita,"")
    return testoIndiceNew

        
    
    
    
        
    
    

def creaPagina(nome):
   site = wikipedia.getSite()
   page = wikipedia.Page(site, nome)
   return Autore(page)

def qualitaIndice(nomeIndice="Indice:Africa orrenda.djvu"):
    listaQi=elencoPagineIndice(nomeIndice,True,True)
    print "Numero elementi:",len(listaQi)
    maxq=0
    testoLista="/n".join(listaQi)
    
    if 'class="new"' in testoLista:
        maxq=1
        
    elif 'class="quality1"' in testoLista:
        maxq=1
        
    elif 'class="quality2"' in testoLista:
        maxq=2
        
    elif 'class="quality3"' in testoLista:
        maxq=3
        
    elif 'class="quality4"' in testoLista:
        maxq=4

    return maxq

        
        
        


def elencoPagineIndice1(indice,tutte=False):
    #elenco_pagine=[]
    #inizializzazione oggetto Page su pagina indice
    site=wikipedia.getSite()
    page=wikipedia.Page(site,indice)

    # calcolo nome x url
    nomeindice="/wiki/"+page.urlname()
    
    #lettura HTML originario (prima delle alterazioni js)
    testo=leggi_pagina_html(nomeindice)
    
    #ricerca di tutti i tag <a href..>...</a> e salvataggio su file
    pagine=produci_lista(testo,'<a href="',"</a>",1)
    titoli=[]
    for i in pagine:
         if tutte:
           if ('title="Pagina:' in i) and ("class=" in i):
               titolo=find_stringa(i,'title="','"').replace(" (tuttora non scritto)","")
               #qp=find_stringa(i,'class="','"')
               if not titolo in titoli:
                   #elenco_pagine.append([titolo,qp])
                   titoli.append(titolo)
         else:
            if ('title="Pagina:' in i) and ("class=" in i) and (not " (tuttora non scritto)" in i):
               titolo=find_stringa(i,'title="','"')
               if not titolo in titoli:
                  titoli.append(titolo)
            

    return titoli
   
def azzeraDumpNuovePagine(ns="Pagina"):
   if ns in ["Autore","Principale","Indice","Pagina"]:
      salva_pcl([],"nuove"+ns)
   else:
      print ns,' : parametro errato (usa uno fra ["Autore","Principale","Indice","Pagina"]'
   return

def aggiornaAutore(pagina,commento="Aggiornamento autore via Alebot"):
   wikipedia.setAction=commento
   pagina.page.put(pagina.testo,comment=commento)
   wikipedia.stopme()
   return "Fatto"
   

"""File downloading from the web.
"""

   
def download(url):
	"""Copy the contents of a file from a given URL
	to a local file.
	"""
	import urllib
	webFile = urllib.urlopen(url)
	localFile = open("immagini/"+url.split('/')[-1], 'w')
	localFile.write(webFile.read())
	webFile.close()
	localFile.close()

if __name__ == '__main__':
	import sys
	if len(sys.argv) == 2:
		try:
			download(sys.argv[1])
		except IOError:
			print 'Filename not found.'
	else:
		import os
		print 'usage: %s http://server.com/path/to/filename' % os.path.basename(sys.argv[0])

def go(secondi=1800, cicli=20):
   ''' ciclo timer che chiama leggi_richieste ogni n secondi per m volte

   Utilizzato nel bot interattivo'''
   rcSession()
   for i in range(cicli):
      t=Timer(secondi, rcSession)
      t.start()
      t.cancel()
   return

def estraiSectionAc():
   ac=leggi_pagina("Template:Ac/Dati")
   l1=produci_lista(ac, "<section begin","/>",1)
   l2={}  
   for i in l1:
      autoreBreve=i.replace("<section begin=","").replace(" />","")
      autoreLungo=find_stringa(ac,i,i.replace("begin=","end="))
      l2[autoreBreve]=autoreLungo
   return l2

def normalizzaAc(ac): #riceve un tl Ac
   ac=ac.replace("{{a","{{A")
   ac=ac.replace("{{AutoreCitato|","{{Ac|")
   acpar=find_stringa(ac,"{{Ac|","}}").split("|")
   print "acpar:",acpar
   if len(acpar)==1:
      if leggi_pagina("Autore:"+acpar[0])>"":
         acnorm=ac
      elif acpar[0] in autoreCitato:
         acnorm=ac.replace("{{Ac|","{{Ac|"+autoreCitato[acpar[0]]+"|")
      else:
         acnorm=ac
   else:
      acnorm=ac
   return acnorm

def normalizzaAcPagina(testo):
   if "{{autorecitato|" in testo.lower() or "{{ac|" in testo.lower():
      testo=testo.replace("{{autoreCitato|","{{AutoreCitato|")
      testo=testo.replace("{{ac|","{{Ac|")
      testo=testo.replace("{{AutoreCitato|","{{Ac|")
      listaAc=produci_lista(testo,"{{Ac|","}}",1)
      for ac in listaAc:
         acn=normalizzaAc(ac)
         testo=testo.replace(ac,acn)
   return testo

##def move(self, newtitle, reason=None, movetalkpage=True, movesubpages=False, sysop=False,
##             throttle=True, deleteAndMove=False, safe=True, fixredirects=True, leaveredirect=True):
def rinomina(oldtitle,newtitle, leaveRedirect=False, movesubpages=False, movetalkpage=True,site="it"):
   ''' note

   leaveRedirect=False: non lascia dietro redirect (lo sopprime immediatamente)
   safe, deleteAndMove, fixredirects: ignorare (servono a vecchie routine)
   movetalkpage: viene ignorato se si tratta di una pagina di discussione'''
   if leaveRedirect:
      reason="Spostamento pagina via bot con creazione di redirect (default)"
   else:
      reason="Spostamento pagina via bot senza creazione di redirect"
   pagina=wikipedia.Page(site,oldtitle)
   result=pagina.move(newtitle,leaveRedirect=leaveRedirect,safe=safe,
                      movesubpages=movesubpages,movetalkpage=movetalkpage, reason=reason)
   return
   
   
   
   
# Parte attiva del programma

autoreCitato=estraiSectionAc()
vai=raw_input("Avvio il bot?")
if vai.lower() in ["s","si"]:
    secondi= raw_input("Secondi fra i cicli:")
    if secondi=='':
       secondi=1800
    else:
       secondi=eval(secondi)
    
    numeroCicli=raw_input("Numero cicli:")
    if numeroCicli=='':
       numeroCicli=20
    else:
       numeroCicli=eval(numeroCicli)
       
       go(secondi,numeroCicli)