Progetto:Bot/Programmi in Python per i bot/aubrey.py

Da Wikisource.
Jump to navigation Jump to search
#!/usr/bin/python
# -*- coding: utf-8 -*-
import wikipedia
import pickle
import catlib
import pagegenerators
import table2wiki
from datetime import date
from time import gmtime, strftime
from random import random

__version__ = '0.7'

a="{{"
b="}}"
# richieste supportate:

# table2wiki
# Aggiorna tabella indici
# Aggiorna tabella SAL indici
# aggiungi infotesto


def richieste_bot():
    pr=list_in_cat("Bot calls")
    if len(pr)>0:
        pagina=pr[0]
        testo_pagina=leggi_pagina(pagina)
        richiesta=find_stringa(testo_pagina,"{{ToAlebot","}}",1)
        if not "|done=yes}}" in richiesta:
                richiesta_pendente=richiesta
                richiesta_fatta=richiesta_pendente.replace("}}","|done=yes}}")
                testo_pagina=esegui_richiesta(richiesta,pagina,testo_pagina)
                testo_pagina=testo_pagina.replace(richiesta_pendente,richiesta_fatta)
        scrivi_pagina(testo_pagina, False, pagina, "Alebot edit: bot call"+richiesta)
        print "Richiesta eseguita"
    else:
        print "Nessuna richiesta pendente"
    return

def esegui_richiesta(richiesta,pagina,testo_pagina):
    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 not i in (r_user,r_page):
            r.append(i)
            
        
    print r,r_user,r_page
    print "Richiesta da eseguire:",r[0]
    
    if r[0].lower()=="table2wiki":
        h2w=table2wiki.Table2WikiRobot(None)
        testo_pagina=h2w.markActiveTables(testo_pagina)
        testo_pagina=h2w.convertTable(testo_pagina)[0]
        del h2w
    if r[0].lower()=="roadmap autore":

#######
        autore,note=dati_autore(pagina)
        note=verifica_databox_autore(autore)
        note=verifica_tavole_cronologiche(autore)
        note=verifica_ricorrenze(autore)

#######

        
    elif r[0].lower()==u"qualità":
        azione=bot_qual(pagina,"",richiesta)
    elif r[0].lower()=="aggiorna tabella indici":
        x=prepara_tabella_indici(True,True)
    elif r[0].lower=="aggiorna tabella sal indici":
        x=tabella_indici("Progetto:Trascrizioni/Tabella SAL indici",True)
    elif r[0].lower()=="aggiungi infotesto":
        if r_page=="":
            pagina_base=pagina
        else:
            pagina_base=r_page.replace("page=","")
        x=infotesto(pagina_base)
    elif r[0].lower()=="apostrofi":
        if r_page=="":
            pagina_base=pagina
        else:
            pagina_base=r_page.replace("page=","")
        x=vao(pagina_base)
        testo_pagina=leggi_pagina(pagina_base)
        
    return testo_pagina

def vao(link_pagina,numero_pagine=1):
    pag=leggi_pagina(link_pagina)
    print pag
    if pag>"" and not "#REDIRECT" in pag:
        pagine=leggi_capitoli(link_pagina,numero_pagine)
        #print "lista pagine da leggi_capitoli:", pagine
        pagine[0:0]=[link_pagina]
        #print "lista pagine dopo aggiunta pagina_base:", pagine
        for r in pagine:
            pag=leggi_pagina(r)
            if pag>"" and not "#REDIRECT" in pag in pag:
                pag1=apos(pag)
                if pag1!=pag:
                    scrivi_pagina(pag1,False,r)
                    #print pag1
                else:
                    print "Pagina",r,"esaminata ma non modificata"
            
        
    else:
        note="Pagina inesistente o redirect."

    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"<",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
            
    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
    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
    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
    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
    #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])

    return p2

def bot_qual(nome_pagina, testo_pagina, richiesta):
    # {{Qualità|avz=101%|data=30 aprile 2009|arg=poemi}}
    testo_pagina=leggi_pagina(nome_pagina)
    schemaq= u"{{Qualità|avz=xx|data="+oggi()+"|arg=}}"
    r=find_stringa(richiesta, "{{","}}").split("|")
    print r
    q=r[2].replace("%","").replace("avz=","")
    r[3]=r[3].replace("arg=","")
    print "Valore q:",q
    if q in "25,50,75,100":
        defaultq=schemaq.replace("xx",q+"%")
        if len(r)==4:
            defaultq=defaultq.replace("arg=","arg="+r[3])
        
        print "Qualità:", defaultq
        xx= find_stringa(testo_pagina,u"{{Qualità",u"}}") 
        print "find_stringa:",xx
        if not find_stringa(testo_pagina,u"{{Qualità",u"}}"):
            print "assegno a", nome_pagina, defaultq
            testo_pagina=defaultq+testo_pagina
            testo_pagina=testo_pagina.replace(richiesta,"")
            scrivi_pagina(testo_pagina, False,nome_pagina,"Alebot: Assegno SAL "+q+"%")
    if not "/" in nome_pagina:
        pagine=leggi_capitoli(nome_pagina,numero_pagine=0)
        print pagine
        for nome_pagina in pagine:
            if not "Cavalleria rusticana" in nome_pagina:
                testo_pagina=leggi_pagina(nome_pagina)
                if not find_stringa(testo_pagina,u"{{Qualità",u"}}"):
                    print "assegno a", nome_pagina, defaultq
                    testo_pagina=defaultq+testo_pagina
                    testo_pagina=testo_pagina.replace(richiesta,"")
                    scrivi_pagina(testo_pagina, False,nome_pagina,"Alebot: Assegno SAL "+q+"%")
                else:
                    print "Non assegno qualità a", nome_pagina
    return "Fatto"

def leggi_capitoli(titolo,numero_pagine=1):
    if not "Indice:" in titolo:
        pagina=leggi_pagina(titolo)
        if "{{testo|" in pagina:
            pagina=pagina.replace("{{testo|","{{Testo|")
        capitoli=produci_lista(pagina,"{{Testo|","}}")
        for i in range(len(capitoli)):
            if "|" in capitoli[i]:
                capitoli[i]=capitoli[i][:capitoli[i].find("|")]
            #p=leggi_pagina(capitoli[i])
            #print capitoli[i], len(p)
    else:
        pagina=leggi_pagina(titolo)
        if "<pagelist" in pagina:
            capitoli=[]
            nome_base=titolo.replace("Indice:","")
            if not ".djvu" in nome_base:
                nome_base=nome_base+".djvu"
            print nome_base
            numero_pagine=cerca(nome_base)
            pg=titolo.replace("Indice:","Pagina:")
            for i in range(numero_pagine):
                capitoli.append(pg+"/"+str(i+1))
                

        else:
            capitoli=produci_lista(pagina,"[[","|")
        
    print capitoli
    return capitoli

def cerca(p="Il cavallarizzo.djvu"):
    pag="Pagina:"+p+"/"
    print pag
    ma=1000
    mi=0
    while True:
        vc=ma
        p=leggi_pagina(pag+str(vc))
        if p=="":
            ris="Troppo"
        else:
            ris="Poco"
        print pag+str(vc),ris
        if ris=="Troppo":
            test=leggi_pagina(pag+str((ma+mi)/2))
            if test=="":
                ma=(ma+mi)/2
            else:
                mi=(ma+mi)/2
        
                              
        #print "Tento ",mi,ma
        if ma-mi<2:
            break
    return mi

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
# riceve il titolo di una pagina testuale principale e restituisce la lista
# della pagine elencate nellasua sezione indice all'interno di un tl|Testo.
# Il formato della lista è [[titolo,""],[titolo,""]...] per uniformarlo all'analogo
# script per le pagine indice
def elenco_capitoli(titolo):
    pagina=leggi_pagina(titolo)
    if "{{testo|" in pagina:
        pagina=pagina.replace("{{testo|","{{Testo|")
    capitoli=produci_lista(pagina,"{{Testo|","}}")
    for i in range(len(capitoli)):
        if "|" in capitoli[i]:
            capitoli[i]=capitoli[i][:capitoli[i].find("|")]
        capitoli[i]=[capitoli[i], ""]                  
    return capitoli

# riceve il titolo di una pagina Indice e restituisce la lista
# della pagine, sia che siano presenti, sia che siano "link rossi".
# Il formato della lista è [[titolo,qualità],[titolo,qualità]...] dove qualità
# è uno dei valori quality0,...quality4, new.
def elenco_pagine_indice(indice):
    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 ('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)

    return elenco_pagine
        
# ricevuta una pagina Indice, analizza il PageQuality di ciascuna delle sue
# pagine, valuta il SAL complessivo dell'indice, lo scrive o lo aggiorna,
# e restituisce la valutazione complessiva in una riga di testo, e la lista
# delle pagine. 
    

def qualityPagine(indice="Indice:Narcissa.djvu"):
    '''calcola la qualità delle pagine di un indice

Restituisce una riga della tabella "Elenco indici"''' 
    testo_wiki=leggi_pagina(indice)

    #lettura qualità
    template_qualita=find_stringa(testo_wiki,u"{{Qualità|","}}",1)
    if template_qualita=="":
        template_qualita=u"{{Qualità|avz=00%|data=11 settembre 2009|arg=}}"

    template_qualita_valore=find_stringa(template_qualita,"avz=","|")
    print indice,template_qualita,template_qualita_valore

# interroga elenco_pagine_indice e rivene una lista dei titoli pagina e qualità
    pagine=elenco_pagine_indice(indice) #new
    conteggi={"quality0":0,"quality1":0,"quality2":0,"quality3":0,"quality4":0,"new":0, }
    #lista_quality1=[]
    djvu=False
    for i in pagine:
        if not djvu: # controllo djvu
             if ".djvu" in i[0]:
                djvu=True
                break
    
    for i in pagine:    
        conteggi[i[1]]+=1 # contatore pagine di diversa qualità
    print conteggi
    riga='''|-\n|align=left|{{testo|indice}}||si||qnew||q0||q1||q2||q3||q4\n'''
    riga=riga.replace("indice",indice).replace("qnew",str(conteggi["new"]))
    riga=riga.replace("q2",str(conteggi["quality2"]))
    riga=riga.replace("q3",str(conteggi["quality3"])).replace("q4",str(conteggi["quality4"]))

    #analisi pagine quality1 se non sono >20
    if conteggi["quality1"]<21:
        for i in pagine:
            if 'quality1' in i[1]:
                p=leggi_pagina(i[0])
                if "PageQuality|0" or '<pagequality level="0"' in p:
                    conteggi["quality1"]=conteggi["quality1"]-1
                    conteggi["quality0"]=conteggi["quality0"]+1
    # calcolo qualità complessiva
    qi="100%"
    if conteggi["quality3"]>0:
        qi="75%"
    if conteggi["quality2"]>0:
        qi="50%"
    if conteggi["quality1"]>0 or conteggi["new"]>0:
        qi="25%"
        
    riga=riga.replace("q0",str(conteggi["quality0"])).replace("q1",str(conteggi["quality1"]))    
    riga=riga.replace("||0","||<br />")
    print riga
    
    if not djvu:
        riga=riga.replace("||si||","||no||")
    #print riga
    print "Qualità indice rivalutata:",qi,"vs.",template_qualita_valore
            
    if not qi == template_qualita_valore:
        template_qualita_new=template_qualita.replace(template_qualita_valore,qi)
        if u"{{Qualità|avz" in testo_wiki:
            testo_wiki=testo_wiki.replace(template_qualita,template_qualita_new)
        else:
            testo_wiki=testo_wiki.replace("Sommario=","Sommario="+template_qualita_new+"\n")
        scrivi_pagina(testo_wiki,False,indice,commento=u"Aggiornata Qualità indice")
    return riga,pagine

## Riesamina analiticamente il SAL di tutte le pagine indice (e loro pagine)
## e ricostruisce la tabella riassuntiva.
def tabella_indici(pagina_tabella="Progetto:Trascrizioni/Tabella SAL indici",scrivi=True):
    l=list_in_cat("Sommari")
    tabella=[]
    for indice in l:
        print indice
        tabella.append(qualityPagine(indice)[0])
    tabella.sort()
    tabella=u'''{{ToAlebot|Tabella indici|done=yes}}

{|{{prettytable|width=90%|text-align=center}}
|text-align=left width=35%|Titolo||djvu||pagine mancanti||pagine 00%||pagine 25%||pagine 50%||pagine 75%%||pagine 100%
|-
'''+u"\n".join(tabella)+u"\n|}"
    if scrivi:
        scrivi_pagina(tabella,False,pagina_tabella)
    return 







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 infotesto(pagina_base):
    if pagina_base.startswith("Indice:"):
        lista_pagine=elenco_pagine_indice(pagina_base)
        daTranscludere="{{"+pagina_base.replace("Indice:","Discussioni indice:")+"}}"
    else:
        lista_pagine=elenco_capitoli(pagina_base)
        daTranscludere="{{Discussione:"+pagina_base+"}}"
    print  lista_pagine
    for i in lista_pagine:
        if i[0].startswith("Pagina:"):
            pagina_corrente=i[0].replace("Pagina:","Discussioni pagina:")
        else:
            pagina_corrente="Discussione:"+i[0]
        if leggi_pagina(pagina_corrente)=="":
            scrivi_pagina(daTranscludere,False,pagina_corrente)
        else:
            print pagina_corrente,"OK"
    return
                
 
##wiki reading/writing
                      
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=u"Prova\n\n",aggiungi=True ,nome_pagina=u"Utente:Alebot/Sandbox",commento="Edit by Alebot"):
    site = wikipedia.getSite()
    page = wikipedia.Page(site, nome_pagina)
    wikipedia.setAction=commento
    if aggiungi:
        contenuto = page.get()
        page.put(contenuto+u"\n\n"+testo,comment=commento)
    else:
        page.put(testo,comment=commento)
    wikipedia.stopme()
    return "Fatto"





def carica_pagine_indice():
    indici=list_in_cat("Sommari")
    indici_dump=[]
    for i in range(len(indici)):
        x=leggi_pagina(indici[i])
        xx=find_stringa(leggi_pagina(indici[i].replace("Indice:","Discussioni indice:")), u"{{Infotesto",u"}}",1)
        indici_dump.append("<!--NomeIndice:"+indici[i]+"-->\n"+x+xx)
        print indici[i]
    salva_pcl(indici_dump,"indici_dump")
        
    return indici, indici_dump

def prepara_tabella_indici(leggi=True,scrivi=True):
    if leggi:
        indici,indici_dump=carica_pagine_indice()
    else:
        indici=list_in_cat("Sommari")
        print "Trovati", len(indici), "indici"
        indici_dump=carica_pcl("indici_dump")
                               
    #riga=u'''|-\n|{{Testo|§indice}}||[[Autore:§autore|§autore]]||{{Testo|§nome opera}}||§edizione||§città di edizione||§anno||[§fonte <small>fonte</small>]\n'''
    riga=u'''|-
|style="background:#eeeeee;font-size:90%"|{{Testo|§indice}}
|style="background:#eeeeee;font-size:90%"|[[Autore:§autore|§autore]]
|style="background:#eeeeee;font-size:90%"|{{Testo|§nome opera}}
|style="background:#eaeaea;font-size:90%"|§edizione
|style="background:#eaeaea;font-size:90%"|§città di edizione
|style="background:#eaeaea;font-size:90%"|§anno
|style="background:#e6e6e6;font-size:90%"|[§fonte <small>fonte</small>]
'''


    header=u'''La tabella è scritta da [[Utente:Alebot|Alebot]] sulla base dei contenuti di [[:Categoria:Sommari]], delle pagine Indice e testuale e dei relativi Infotesto. Non modificare i contenuti, ogni modifica sarebbe
comunque azzerata dalla successiva riscrittura della pagina da parte del bot. 

Ultimo aggiornamento:{{subst:CURRENTDAY}} {{subst:CURRENTMONTH}} {{subst:CURRENTYEAR}}


{| {{prettytable|width=100%|text-align=left}}
| colspan="7" align="center" style="background:#D0F0C0"|\'\'\'Tabella delle pagine Indice\'\'\'
|-
!width=25% align="center" style="background:#D0F0C0;font-size:90%"|\'\'\'Indice\'\'\'
!width=10% align="center" style="background:#D0F0C0;font-size:90%"|\'\'\'Autore\'\'\'
!width=25% align="center" style="background:#D0F0C0;font-size:90%"|\'\'\'Versione testuale\'\'\'
!width=15% align="center" style="background:#FFFF66;font-size:90%"|\'\'\'Edizione\'\'\'
!width=10% align="center" style="background:#FFFF66;font-size:90%"|\'\'\'Città\'\'\'
!width=5% align="center" style="background:#FFFF66;font-size:90%"|\'\'\'Anno\'\'\'
!width=5% align="center" style="background:#ccccff;font-size:90%"|\'\'\'Fonte web\'\'\'
'''
    #header=header+u"!width=25%|'''Indice'''||width=10%|'''Autore'''||width=25%|'''Versione testuale'''||width=15%|'''Edizione'''||width=10%|'''Città'''||width=5%|'''Anno'''||width=5%|'''Fonte'''\n"
    footer=u"|}\n"
    tabella=header
    for i in range(len(indici)):
        print "Passo ",i
        dati=dati_indice(indici_dump[i])
        for j in dati.keys():
            if dati[j]=="":
                dati[j]="<br />"
        # autore, nome opera, edizione, citta di edizione, anno
        if dati["Autore"]=="<br />":
            riga_c=riga.replace(u"[[Autore:§autore|§autore]]",dati["Autore"])
        else:           
            riga_c=riga.replace(u"§autore",dati["Autore"])
        riga_c=riga_c.replace(u"§indice",indici[i])
        if dati["NomePagina"]=="<br />":
            riga_c=riga_c.replace(u"[[§nome opera]]",dati["NomePagina"])
        else:
            riga_c=riga_c.replace(u"§nome opera",dati["NomePagina"])
        riga_c=riga_c.replace(u"§edizione",dati["Editore"])
        riga_c=riga_c.replace(u"§città di edizione",dati[u"Città"])
        riga_c=riga_c.replace(u"§anno",dati["Anno"])
        if dati["Fonte"]=="<br />":
            riga_c=riga_c.replace(u"[§fonte <small>fonte</small>]",dati["Fonte"])
        else:
            riga_c=riga_c.replace(u"§fonte",dati["Fonte"])
        #riga_c=riga_c.replace(u"§sal","<br />")
        tabella=tabella+riga_c
    tabella=tabella+footer
    if scrivi:
        scrivi_pagina(tabella,False,"Progetto:Trascrizioni/Tabella delle pagine Indice")
    else:
        return tabella

    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

def salva(variabile,nome_file="dato"):
    nome_file="dati/"+nome_file+".pcl"
    f=open(nome_file,"w")
    pickle.dump(variabile, f)
    f.close()
    return "Variabile salvata nel file "+nome_file

def salva_pcl(variabile,nome_file="dato"):
    nome_file="dati/"+nome_file+".pcl"
    f=open(nome_file,"w")
    pickle.dump(variabile, f)
    f.close()
    return "Variabile salvata nel file "+nome_file




## 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


# 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 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
####
# Dati e routine per roadmap autore
####
dic={}
riscontro=u'''<noinclude>Il seguente template raccoglie i dati necessari alla corretta compilazione della Tabella autori 

=== Istruzioni ===
*\'''Date\''': Data di nascita e di morte dell'autore
*\'''Prof/Naz\''': Professione e nazionalità
*\'''Wikipedia\''': Presenza della voce su Wikipedia. X indica che su Wikisource è presente il rimando verso Wikipedia; R indica che su Wikipedia è presente il rimando verso Wikisource 
*\'''Wikiquote\''': Presenza della voce su Wikiquote. X indica che su Wikisource è presente il rimando verso Wikiquote; R indica che su Wikiquote è presente il rimando verso Wikisource 
*\'''Commons\''': Presenza della voce su Commons 
*\'''Foto\''': Presenza del ritratto o fotografia dell'autore 
*\'''Anni\''': Presenza dell'indicazione degli anni in tutte le opere elencate per le quali tale dato è disponibile 
*\'''SAL\''': Presenza dell'icona SAL in tutte le opere elencate 
*\'''Interwiki\''': Presenza degli interwiki. Indicare le sigle degli interwiki presenti. 
*\'''Controllo\''': Giorno in cui è stato effettuato il controllo

Vedi anche [[Progetto:Qualità/Tabella_degli_autori|Tabella degli autori]].


</noinclude>{{Utente:Alex_brollo/RiscontroAutore 
| autore=#NomeAutore
| link=[http://it.wikisource.org/w/index.php?title=Template:#HtmlNomeAutore/Riscontro&action=edit modifica dati]
| date=  
| prof_naz=  
| wikipedia=  
| wikiquote=  
| commons=  
| foto=  
| anni=  
| SAL=  
| interwiki=  
| data_controllo=  
}}<noinclude>[[Categoria:Template di prova]][[Categoria:Template di servizio per i progetti]]</noinclude>
'''

interlink=["[[en:", "[[fr:", "[[zh:", "[[es:", "[[de:", "[[ru:", "[[it:",\
           "[[pt:", "[[fa:", "[[th:", "[[pl:", "[[hu:", "[[he:", "[[ro:", \
           "[[cs:", "[[hr:", "[[ar:", "[[te:", "[[fi:", "[[tr:", "[[nl:", \
           "[[sv:", "[[sr:", "[[la:", "[[ja:", "[[sl:", "[[ml:", "[[uk:", \
           "[[is:", "[[bs:", "[[el:", "[[ko:", "[[id:", "[[ca:", "[[bn:", \
           "[[li:", "[[no:", "[[hy:", "[[da:", "[[az:", "[[vi:", "[[ta:", \
           "[[et:", "[[mk:", "[[bg:", "[[yi:", "[[kn:", "[[lt:", "[[sk:", \
           "[[cy:", "[[gl:", "[[zh-min-nan:", "[[ht:", "[[fo:", "[[ang:"]

note="Note:"

def verifica_databox_autore(autore):
    note=""
    #autore=find_stringa(ric,u'[[Autore:',']]',1)
    #pagina_autore=find_stringa(autore,"[[","]]")
    nome_autore=autore["pagina"].replace("Autore:","")
    
    #azione
    template_autore=find_stringa(leggi_pagina(autore["pagina"]),"{{Autore","}}\n",1)
    template_autore1=template_autore.replace("{{Autore","{{subst:Autore1")+"\n<!-- nuova versione -->"
    pagina_dati="Template:"+nome_autore+"/Dati"
    scrivi_pagina(template_autore1,False,pagina_dati)
    # fine azione

    note=scrivi_template_riscontro(autore)
    note=verifica_tabella_autori(autore)
    if note=="":
        note="Databox, riscontro, tabella autori OK."
    
    return note
def verifica_tabella_autori(autore):
    iniziale=autore["iniziale"]
    if iniziale in "A":
        n=1
    elif iniziale in "BC":
        n=2
    elif iniziale in "DEFGH":
        n=3
    elif iniziale in "IJKLM":
        n=4
    elif iniziale in "NOPQ":
        n=5
    else:
        n=6
    nome_tabella=u"Progetto:Qualità/Tabella degli autori/"+str(n)
    tabella=leggi_pagina(nome_tabella)
    if not autore["pagina"].replace("Autore:","Template:") in tabella:
        print autore["pagina"],"mancante in",nome_tabella
        tabella=tabella.split("\n")
        riga="{{"+autore["pagina"].replace("Autore:","Template:")+"/Riscontro}}"
        riferimento_autore=autore["cognome"]+" "+autore["nome"].strip()
        if not riferimento_autore[0:1]==iniziale:
            r=riferimento_autore.split()
            for i in range(len(r)):
                if r[i][0:1]==iniziale:
                    riferimento_autore=r[i]
                    break
        for i in range(len(tabella)):
            if u"IntestazioneTabella|"+iniziale in tabella[i]:
                p=i+1
                break
        for i in range(p,len(tabella)):
            if u"IntestazioneTabella|" in tabella[i] or "<noinclude>" in tabella[i]:
                tabella[i:i]=[riga]
            else:
                riferimento=find_stringa(tabella[i],"{{Template:","/Riscontro").split()
                for j in range(1,len(riferimento)):
                    if riferimento[j][0:1]==iniziale:
                        riferimento=riferimento[j]+" "+riferimento[0]
                        break
                    elif j==len(riferimento)-1:
                        riferimento=" ".join(riferimento)
            if riferimento_autore<riferimento:
                tabella[i:i]=[riga]
                break

        print riferimento_autore, riferimento
        tabella="\n".join(tabella)
        scrivi_pagina(tabella,False,nome_tabella)
        note=""
    else:
        print "La pagina",nome_tabella,"contiene",autore["pagina"]
        note=""
    return note

def verifica_tavole_cronologiche(autore):
    riga,note=tavole_cronologiche(autore)
    riga="  "+riga
    
    if note=="OK":# and find_stringa(riga,"from:","till:").strip().isdigit():
        from_autore=eval(find_stringa(riga,"from:","till:"))
        pagina1,pagina2=pagine_cronologia(riga)
        pagina=leggi_pagina(pagina1)
        if autore["pagina"] in pagina:
            print "OK in ",pagina1
        else:
            pagina=pagina.split("\n")
            r=[]
            for i in range(len(pagina)):
                if u'text:"[[Autore:' in pagina[i]:
                    r.append(i)
            for i in range(len(r)):
                if from_autore<=eval(find_stringa(pagina[r[i]],"from:","till")):
                    pagina[r[i]:r[i]]=[riga]
                    break
                elif i==len(r)-1:
                    pagina[r[i]+1:r[i]+1]=[riga]
            pagina="\n".join(pagina)
            scrivi_pagina(pagina,False,pagina1)
        if pagina1 != pagina2:
            pagina=leggi_pagina(pagina2)
            if autore["pagina"] in pagina:
                print "OK in ",pagina2
            else:
                pagina=pagina.split("\n")
                r=[]
                for i in range(len(pagina)):
                    if u'text:"[[Autore:' in pagina[i]:
                        r.append(i)
                for i in range(len(r)):
                    if from_autore<=eval(find_stringa(pagina[r[i]],"from:","till")):
                        pagina[r[i]:r[i]]=[riga]
                        break
                    elif i==len(r)-1:
                        pagina[r[i]+1:r[i]+1]=[riga]
                pagina="\n".join(pagina)
                scrivi_pagina(pagina,False,pagina2)
        
    return note
def pagine_cronologia(riga):
    ''' riceve una riga autore-cronologia e restituisce i nomi pagina periodo storico-secolo

    '''
    
    dn=eval(find_stringa(riga,"from:","till:"))
    dm=eval(find_stringa(riga,"till:","text:"))
    
    if dn>-500 and dn<501:
        pagina1=u"Wikisource:Tavole cronologiche degli autori dell'Antichità"
    elif dn<1001:
        pagina1=u"Wikisource:Tavole cronologiche degli autori dell'Alto Medioevo"
    else:
        secolo=romani(dn/100+1)
        pagina1=u"Wikisource:Tavole cronologiche degli autori del "+secolo+" secolo"
    if dm>-500 and dm<501:
        pagina2=u"Wikisource:Tavole cronologiche degli autori dell'Antichità"
    elif dm<1001:
        pagina2=u"Wikisource:Tavole cronologiche degli autori dell'Alto Medioevo"
    else:
        secolo=romani(dm/100+1)
        pagina2=u"Wikisource:Tavole cronologiche degli autori del "+secolo+" secolo"
    return pagina1,pagina2

def romani(n):
    r=",I,II,III,IV,V,VI,VII,VIII,IX,X,XI,XII,XIII,XIV,XV,XVI,XVII,XVIII,XIX,XX,XXI"
    r=r.split(",")
    return r[n]

def scrivi_template_riscontro(autore):
    '''Se manca scrive un template nomeautore/riscontro

    Riceve il dizionario Autore e restituisce eventuali note'''
    note=""
    # crea indirizzo pagina
    template_riscontro=u"Template:#1/Riscontro"
    nome_autore=autore["pagina"].replace("Autore:","")
    nome_autore_html=nome_autore.replace(" ","_")
    template_riscontro=template_riscontro.replace("#1",nome_autore_html)
    #leggi pagina
    pag_riscontro=leggi_pagina(template_riscontro)

    #se la pagina non esiste o è un reditect creala
    if len(pag_riscontro)==0 or pag_riscontro==u"#REDIRECT":
        
        pag_riscontro=riscontro
        pag_riscontro=pag_riscontro.replace(u"#NomeAutore",nome_autore)
        pag_riscontro=pag_riscontro.replace(u"#HtmlNomeAutore",nome_autore_html)
        if len(autore["gm_nascita"])>0 and len(autore["a_nascita"])>0 and len(autore["gm_morte"])>0 and len(autore["a_morte"])>0:
            pag_riscontro=pag_riscontro.replace(u"| date= ",u"| date= "+"x")
        if len(autore["prof_naz"])>0:
            pag_riscontro=pag_riscontro.replace(u"| prof_naz= ",u"| prof_naz= "+"x")
        if len(autore["wikipedia"])>0:
            pag_riscontro=pag_riscontro.replace(u"| wikipedia= ",u"| wikipedia= "+"x")
        if len(autore["wikiquote"])>0:
            pag_riscontro=pag_riscontro.replace(u"| wikiquote= ",u"| wikiquote= "+"x")
        if len(autore["commons"])>0:
            pag_riscontro=pag_riscontro.replace(u"| commons= ",u"| commons= "+"x")
        if len(autore["immagine"])>0:
            pag_riscontro=pag_riscontro.replace(u"| foto= ",u"| foto= "+"x")

        interwiki=""
        testo=autore["testo_pagina"]
        for r in interlink:
            if r in testo:
                if len(interwiki)>0:
                    interwiki=interwiki+", "
                interwiki=interwiki+find_stringa(r,"[[",":")
        if len(interwiki)>0:
            pag_riscontro=pag_riscontro.replace(u"| interwiki= ",u"| interwiki= "+interwiki) 
            
        
        pag_riscontro=pag_riscontro.replace(u"| data_controllo= ",u"| data_controllo= "+strftime("%d %b %Y", gmtime())+" bot")
        scrivi_pagina(pag_riscontro,False,template_riscontro)
    else:
        pass # qui inserire la routine di revisione di una pagina esistente 

    return note

def verifica_ricorrenze(autore):
    '''verifica la presenza delle due ricorrenze per l'autore e le corregge

    '''
    dmn=autore["gm_nascita"].split()
    dmm=autore["gm_morte"].split()
    print autore["gm_nascita"],autore["gm_morte"]
    if len(dmn)==2 and dmn[1] in u"gennaio,febbraio,marzo,aprile,maggio,giugno,luglio,agosto,settembre,ottobre,novembre,dicembre":
        if autore["pagina"] in leggi_pagina("wikisource:Ricorrenze/"+autore["gm_nascita"]):
            note="Ricorrenza nascita OK; "
        else:
            aggiorna_ricorrenza(autore, "nascita")
            note="Aggiornata ricorrenza nascita; "
    else:
        note="Data nascita non conforme: "+autore["gm_nascita"]+" ;"
    if len(dmm)==2 and dmm[1] in "gennaio,febbraio,marzo,aprile,maggio,giugno,luglio,agosto,settembre,ottobre,novembre,dicembre":
        if autore["pagina"] in leggi_pagina("wikisource:Ricorrenze/"+autore["gm_morte"]):
            note=note+"ricorrenza morte OK."
        else:
            aggiorna_ricorrenza(autore, "morte")
            note=note +"aggiornata ricorrenza morte."
    else:
        note=note +"data morte non conforme: "+autore["gm_morte"]+"."
    return note
    
def tavole_cronologiche(autore):
    ''' riceve dizionario autore e restituisce una riga di codice e una nota

    Se il controllo dati passa, viene restituita la riga e OK; se il controllo
    non passa, restituisce riga vuota e note descrittive dell'errore'''
    
    riga='from:#1  till:#2 text:"[[Autore:#3|#3]]" color:BarraVita'
    dn=autore["a_nascita"].strip()
    dm=autore["a_morte"].strip()
    aut=autore["pagina"].strip()
    digits=u"-0123456789 "
        
    # selezione date accettabili
    if dn=="" or dm=="":
        note="Manca anno nascita o anno morte; se vivente aggiungere manualmente"
        return "",note
    test=dn.split()
    if len(test)>2:
        note="Anno nascita non conforme"
        return "",note
    if len(test)==2 and test[1]==u"a.C.":
        dn="-"+test[0]
    elif len(test)==2 and test[1]!=u"a.C.":
    #print len(test),test[0],test[1],dn
        note="Anno nascita non conforme"
        return "",note

    test=dm.split()
    if len(test)>2:
        note="Anno morte non conforme"
        return "",note
    if len(test)==2 and test[1]==u"a.C.":
        dm="-"+test[0]
    elif len(test)==2 and test[1]!=u"a.C.":
    #print len(test),test[0],test[1],dn
        note="Anno morte non conforme"
        return "",note
    #print len(test),test[0],test[1],dm
        
    for i in dn:
        #print dn
        if not i in digits:
            #print i
            note="Anno nascita (cifre) non conforme"
            return "",note
    for i in dm:
        if not i in digits:
            note="Anno morte non conforme"
            return "",note
    dn=eval(dn)        
    dm=eval(dm)
    autn=aut.replace("Autore:","")
    riga=riga.replace("#1",str(dn))
    riga=riga.replace("#2",str(dm))
    riga=riga.replace("#3",autn)
    note="OK"
    return riga, note

def dati_autore(titolo_pagina_autore,fonte="web",dictionary=dic):
    ''' legge una pagina autore e estrae i dati

    Da rivedere per aubrey.py (escludere l'opzione dictionary)'''
    
    if fonte=="web" and not "Autore:" in titolo_pagina_autore:
        titolo_pagina_autore="Autore:"+titolo_pagina_autore.strip()
    autore_dic={}
    note=""
  
    pagina_autore=leggi_pagina(titolo_pagina_autore) # sostituisce 
    autore_dic["pagina"]=titolo_pagina_autore
    autore_dic["testo_pagina"]=pagina_autore
    if pagina_autore=="":
        note="Pagina autore inesistente"
        return autore_dic, note
    elif "REDIRECT" in pagina_autore:
        note="Pagina #Redirect"
        return autore_dic, note

    autore_dic["nome"]=find_stringa(pagina_autore,u"| Nome =","\n").strip()
    autore_dic["cognome"]=find_stringa(pagina_autore,u"| Cognome =","\n").strip()
    autore_dic["iniziale"]=find_stringa(pagina_autore,u"| Iniziale del cognome =","\n").strip()
    autore_dic["altro_nome"]=find_stringa(pagina_autore,u"| Eventuale altro nome =","\n").strip()
    autore_dic["nome_reale"]=find_stringa(pagina_autore,u"| Eventuale nome reale =","\n").strip()
    autore_dic["gm_nascita"]=find_stringa(pagina_autore,u"| Giorno e mese di nascita =","\n").strip()
    autore_dic["a_nascita"]=find_stringa(pagina_autore,u"| Anno di nascita =","\n").strip()
    autore_dic["gm_morte"]=find_stringa(pagina_autore,u"| Giorno e mese di morte =","\n").strip()
    autore_dic["a_morte"]=find_stringa(pagina_autore,u"| Anno di morte =","\n").strip()
    autore_dic["secolo"]=find_stringa(pagina_autore,u"| Secolo di attività =","\n").strip()
    autore_dic["secolo2"]=find_stringa(pagina_autore,u"| Eventuale secondo secolo di attività =","\n").strip()
    autore_dic["prof_naz"]=find_stringa(pagina_autore,u"| Professione e nazionalità =","\n").strip()
    autore_dic["wikipedia"]=find_stringa(pagina_autore,u"| Nome della pagina su Wikipedia =","\n").strip()
    autore_dic["wikiquote"]=find_stringa(pagina_autore,u"| Nome della pagina su Wikiquote =","\n").strip()
    autore_dic["wikinotizie"]=find_stringa(pagina_autore,u"| Nome della pagina su Wikinotizie =","\n").strip()
    autore_dic["commons"]=find_stringa(pagina_autore,u"| Nome della pagina su Commons =","\n").strip()
    autore_dic["immagine"]=find_stringa(pagina_autore,u"| Nome dell'immagine =","\n").strip()
    autore_dic["indice"]=find_stringa(pagina_autore,u"| Vuoi l'indice dei contenuti? =","\n").strip()
    autore_dic["testi"]=find_stringa(pagina_autore,u"| Abbiamo testi scritti dall'autore? =","\n").strip()
    autore_dic["traduzioni"]=find_stringa(pagina_autore,u"| Abbiamo traduzioni scritte dall'autore? =","\n").strip()
    autore_dic["citazioni"]=find_stringa(pagina_autore,u"| L'autore è citato in altre opere pubblicate? =","\n").strip()
    #verifiche e correzioni
    errori=False
    correzioni=False
    #controllo campi giorno/mese
    test=autore_dic["gm_nascita"]
    if test>"":
        tests=test.split()
        if len(tests) !=2 or (not tests[0].isdigit()) or (not tests[1] in u"gennaio,febbraio,marzo,aprile,maggio,giugno,luglio,agosto,settembre,ottobre,novembre,dicembre"):
               errori=True
               note=note+"Campo Giorno e data nascita errato: "+autore_dic["pagina"]+" "+test
    test=autore_dic["gm_morte"]
    if test>"":
        tests=test.split()
        if len(tests) !=2 or (not tests[0].isdigit()) or (not tests[1] in u"gennaio,febbraio,marzo,aprile,maggio,giugno,luglio,agosto,settembre,ottobre,novembre,dicembre"):
               errori=True
               note=note+"Campo Giorno e data morte errato: "+autore_dic["pagina"]+" "+test
    #controllo campi anno
    test=autore_dic["a_nascita"]
    if test>"":
        tests=test.split()
        if len(tests)>2:
            errori=True
            note=note+"Campo Anno nascita errato: "+autore_dic["pagina"]+" "+test
        elif len(tests)==2:
            if (not tests[1]=="a.C.") or (not tests[0].isdigit):
                errori=True
                note=note+"Campo Anno nascita errato: "+autore_dic["pagina"]+" "+test
        elif len(tests)==1:
            if not tests[0].isdigit():
                errori=True
                note=note+"Campo Anno nascita errato: "+autore_dic["pagina"]+" "+test

    test=autore_dic["a_morte"]
    if test>"":
        tests=test.split()
        if len(tests)>2:
            errori=True
            note=note+"Campo Anno morte errato: "+autore_dic["pagina"]+" "+test
        elif len(tests)==2:
            if (not tests[1]=="a.C.") or (not tests[0].isdigit):
                errori=True
                note=note+"Campo Anno morte errato: "+autore_dic["pagina"]+" "+test
        elif len(tests)==1:
            if not tests[0].isdigit():
                errori=True
                note=note+"Campo Anno morte errato: "+autore_dic["pagina"]+" "+test
    return autore_dic,note

def aggiorna_ricorrenza(autore,tipo="nascita"): #r : pag. ricorrenza ri : riga entrambe in utf-8 o entrambe in unicode
    if tipo=="nascita":
        data=autore["gm_nascita"]+" "+autore["a_nascita"]
        ri="* "+data+": nasce [["+autore["pagina"]+"|"+autore["nome"]+" "+autore["cognome"]+"]]"
    elif tipo=="morte":
        data=autore["gm_morte"]+" "+autore["a_morte"]
        ri="* "+data+": muore [["+autore["pagina"]+"|"+autore["nome"]+" "+autore["cognome"]+"]]"      
                
    data=data.split()
    if len(data)<3:
        return r
    criterio_ri=data[2]
    if len(data)==4 and data[3].lower()=="a.c.":
        criterio_ri="-"+data[2]
    criterio_ri=eval(criterio_ri)
    pagina_ricorrenze=u"Wikisource:Ricorrenze/"+data[0]+" "+data[1]
    rl=leggi_pagina(pagina_ricorrenze).split("\n")
    trovato_el=False
    el1=-1
    #print rl
    for i in range(len(rl)):
        if u"{{Ricorrenze giorno" in rl[i]:
            urp=i
        elif not trovato_el and rl[i].strip()[0:1]=="*":
            el1=i
            trovato_el=True
        elif u"[[Categoria:Ricorrenze" in rl[i]:
            prs=i
    #print "urp=", urp ,"el1=", el1, "prs=", prs
    if el1==-1: #nessun elemento
        rl[prs:prs]=[ri]
    else: #esistono elementi
        #print "esistono elementi"
        for i in range(el1,prs):
            errore=False
            data=find_stringa(rl[i],"*",":").strip()
            data=data.split()
            if len(data)==3: # non c'è a.C.
                #print data[2],"non c'è a.C."
                criterio=data[2]
            elif len(data)==4 and data[3].lower()=="a.c.":
                criterio="-"+data[2]
            else:
                break

            #print data_ins,criterio
            if criterio_ri<eval(criterio):
                #print "condizione datains<criterio"
                rl[i:i]=[ri]
                break
            elif i==prs-1:
                rl[prs:prs]=[ri]
                break
    rl="\n".join(rl)
    scrivi_pagina(rl,False,pagina_ricorrenze)
    return


### Parte attiva del programma
richieste_bot()