Utente:Alebot/Scripts interattivi

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)