Jump to content

User:Kotbot/Source

From Wikipedia, the free encyclopedia
# Source code (Python) for Kotbot------------

def doros(sta,sto):
    C=F('tclog')[sta:sto+1]; TY=F('tylog'); global g_logcon
    for L in C:
        cy=row(TY,L[1],2)[1]; g_logcon=L[0]; n=nam(L[0])
        tx=wpraw('en',L[0]); iib=iibox(L,cy)
        if 'nfobox' in tx:
            log('settlement' if 'nfobox settlement'\
                in tx else envirs(tx,'nfobox',2,25))
        elif 'ategory:Communes in '+cy not in tx or 'Romania' not in tx:
            log('*wrong page? '+iib)
        elif '{{bot' in tx or '{{nob' in tx or '{{Bot' in tx or '{{Nob' in tx:
            log('*bot exclusion '+iib)
        else:
            x=sf(tx,"'''"+n)
            if x<0 or x>100 or "'''"+n in tx[x+3:]:
                log('*no place for infobox: '+iib)
            else:
                ty=tx[:x]+iibox(L,cy)+'\n'+tx[x:]
                if '<ref>' in ty and '{{reflist}}' not in ty and \
                   '<references' not in ty and '{{Reflist}}' not in ty:
                    if 'eferenc' in ty or 'xternal' in ty or 'Notes' in ty:
                        log('*cant place reflist')
                    else:
                        xx=sf(ty,('\n{{Communes','\n{{communes',
                                  '\n{{DEFAULT','\n[[Category'))
                        if xx<0:
                            log('*cant put ref section')
                        else:
                            ty=ty[:xx]+'\n==References==\n{{reflist}}\n\n'+\
                                ty[xx:]
                            log('*put ref section')
                edit('en',L[0],'Force',ty,
                     'bot adding infobox')
    return sta,sto

def iibox(L,cou):
    t=('{{Infobox settlement\n|name='+nam(L[0])+
       '\n|settlement_type='+
       ('[[Municipiu|City]]' if I(L,5)=='M' else (u9('[[Orasx|Town]]'+
            '') if I(L,5)=='O' else '[[Communes of Romania|Commune]]'))+
       '\n|total_type=&nbsp;\n|image_map=\n|map_caption='+
       '\n|subdivision_type=Country\n|subdivision_name'+
       '={{flag|Romania}}\n|subdivision_type1=[[Counties of Romania|County]]'+
       '\n|subdivision_name1=[['+cou+']]\n|population_total='+L[2])
    if L[2]!='' and L[3]!='':
        t=(t+'\n|population_as_of=2002\n|population_footnotes=<ref>'+
           '[http://recensamant.referinte.transindex.ro/?pg=3&id='+
        L[3]+' Romanian census data, 2002]; retrieved on March 1, 2010</ref>')
    y=a2l(L[4],'|')
    if len(y)==6 and y[0]!='':
        t=(t+'\n|latd='+y[0]+'|latm='+y[1]+'|lats='+y[2]+'|latNS=N'+
           '|longd='+y[3]+'|longm='+y[4]+'|longs='+y[5]+'|longEW=E'+
           '\n|pushpin_map=Romania')
    t=(t+'\n|timezone=[[Eastern European Time|EET]]|utc_offset=+2'+
       '\n|timezone_DST=[[Eastern European Summer Time|EEST]]'+
       '|utc_offset_DST=+3\n}}')
    return t
    
def absss():
    """Coords"""
    T=F('ttlog')
    for L in T:
        tx=wpraw('en',L[0])
        if 'nfobox' in tx:
            ac=''
        else:
            acm=mgp(r'\{\{(?:C|c)oord(.*)\}',tx); ac=ascoo(acm)
        if len(L)==6:
            log(L[0],L[1],L[4],L[5],ac,L[2])
        else:
            log(L+[ac,'**'])
    return 9
        

def oldddoioi():
    TY=col(F('tylog'),2)
    for L in T:
        if len(L)==6:
            if '*' in L[0] or L[1] not in TY \
               or not isnin(L[4],200,1000000) or not isnin(L[5],1,2951) or \
                     S[eval(L[5])-1][3:5]!=[L[1],L[4]]:
                log('*',L[0])
        else:
            if len(L)!=4 or L[1] not in TY or L[3]!='*0':
                log('*',L[0])
    return 9

def abcrc(sta,sto):
    """Get"""
    S=F('sulog'); SV=F('svlog'); T=F('tclog'); TY=F('tylog')
    for L in T[sta:sto+1]:
        na=nam(L[0]); cy=row(TY,L[1],1)[2]
        A=rows(S,na,1)
        B=rows(A,cy,3)
        if len(B)==0:
            A=rows(SV,J2j(rom(na)).replace('-',' '),1)
            B=rows(A,cy,3)
        if len(B)==0:
            A=rows(SV,J2j(rom(na)).replace('-',' ').replace('a',''),1)
            B=rows(A,cy,3)
        if len(B)==1:
            log(L[0],cy,'C',B[0][2],B[0][4],B[0][0])
        else:
            log(L[0],cy,'C','*'+str(len(B)))
    return 9

def achch():
    ty=F('tylog'); c=F('tclog'); s=F('sulog'); R=['']*len(ty)
    for L in c:
        i=lf(ty,L[1],1)
        if R[i]=='':
            M=row(s,L[0],2)
            R[i]=I(M,4)
    for j in range(len(ty)):
        log(ty[j][1],R[j])
    return 9        

def an2():
    g=catcont('en','Communes and villages in Romania')[0]; L=[]
    for k in g:
        if starts(k,'Communes in ') and ends(k,' County'):
            kk=k[12:]
        elif starts(k,'Localities in ') and ends(k,' County'):
            kk=k[14:]
        else:
            kk=k
        log(kk)
        h=catcont('en',k)[1]
        for y in h:
            L=L+[[y,kk]]
    a2fi(L,'blog')
    return 9

#Localities in Ilfov County (incl. 9 towns)

def an1():
    K=F('sourcelog')
    for L in K:
        t=L[2]; c='**'
        if starts(t,'Municipiul '):
            t=t[11:]; c='m'
        elif ends(t,' municipiul'):
            t=t[:-11]; c='m'
        elif starts(t,'Comuna '):
            t=t[7:]; c='c'
        elif ends(t,' comuna'):
            t=t[:-7]; c='c'
        elif ends(t,' c.'):
            t=t[:-3]; c='c'
        elif ends(t,' o.'):
            t=t[:-3]; c='o'
        elif ends(t,' ora\xc5\x9f'):
            t=t[:-6]; c='o'
        elif ends(t,' ora\xc5\x9ful'):
            t=t[:-8]; c='o'
        elif starts(t,'Ora\xc5\x9e '):
            t=t[6:]; c='o'
        elif starts(t,'Ora\xc5\x9eul '):
            t=t[8:]; c='o'
        elif starts(t,'Ora\xc5\x9ful '):
            t=t[8:]; c='o'
        elif ' '!=t:
            c='x'
        log(L[1],noex(t.replace('  ',' ')),c,L[3],L[4])
    return 9

def romget(sta,sto):
    for n in range(sta,sto+1):
        u='http://recensamant.referinte.transindex.ro/?pg=3&id='+str(n)
        t=urlread(u)
        nl=mgps('margin-top.+>(.+?)<',t)
        pl=mgps('<th>Total.+\n.+>(\d+)<',t)
        if len(nl)!=1 or len(pl)!=1 or '>' in nl[0]+pl[0]:
            log(str(n)+'>**>'+str(nl+pl))
        else:
            nj=noex(upto(nam(nl[0]),'/')); ta=tag(nl[0])
            na=replaces(nj,[('\xe2','\xc3\xa2'),
                            ('\xe3','\xc4\x83'),
                            ('\xba','\xc5\x9f'),
                            ('\xfe','\xc5\xa3'),
                            ('\xce','\xc3\x8e'),
                            ('\xaa','\xc5\x9e'),
                            ('\xde','\xc5\xa2')])
            log(str(n),na,ta,pl[0])
    return sta,sto
    
#****************
global g_uni, g_coo, g_lang, g_logfile, g_logcon
global g_user, g_pass, g_jar, g_loggedon

#Unicode characters: lowercase, uppercase, keyboard, (reduction)
g_uni=(('pl',(('\xC4\x85','\xC4\x84','a'),('\xC4\x87','\xC4\x86','c'),
             ('\xC4\x99','\xC4\x98','e'),('\xC5\x82','\xC5\x81','l'),
             ('\xC5\x84','\xC5\x83','n'),('\xC3\xB3','\xC3\x93','o'),
             ('\xC5\x9B','\xC5\x9A','s'),('\xC5\xBA','\xC5\xB9','x','z'),
             ('\xC5\xBC','\xC5\xBB','z'))),
       ('cs',(('\xc3\xa1','\xc3\x81','a'),('\xc4\x8d','\xc4\x8c','c'),
             ('\xc4\x8f','\xc4\x8e','d'),('\xc3\xa9','\xc3\x89','e'),
             ('\xc4\x9b','\xc4\x9a','f','e'),('\xc3\xad','\xc3\x8d','i'),
             ('\xc5\x88','\xc5\x87','n'),('\xc3\xb3','\xc3\x93','o'),
             ('\xc5\x99','\xc5\x98','r'),('\xc5\xa1','\xc5\xa0','s'),
             ('\xc5\xa5','\xc5\xa4','t'),('\xc3\xba','\xc3\x9a','u'),
             ('\xc5\xaf','\xc5\xae','v','u'),('\xc3\xbd','\xc3\x9d','y'),
             ('\xc5\xbe','\xc5\xbd','z'))),
       ('ro',(('\xc3\xa2','\xc3\x82','a'),('\xc4\x83','\xc4\xa3','b','a'),
             ('\xc3\xae','\xc3\x8e','i'),
             ('\xc5\x9f','\xc5\x9e','s'),
             ('\xc5\xa3','\xc5\xa2','t'))))

#Max and min degree 
g_coo=(('pl',(49,54,14,24)),('cs',(48,51,12,18)),('ro',(43,48,20,29)))
g_lang='ro'
g_logfile='blog.txt'
g_logcon=''
g_jar=0
g_loggedon=[]

def I(x,n,df=''):
    """x[n] if exists else default"""
    try:
        return x[n]
    except:
        return df

def lty(a):
    """Returns 2 if a t/list containing t/list(s), 1 if other t/l, else 0"""
    if type(a) not in (tuple,list):
        return 0
    for b in a:
        if type(b) in (tuple,list):
            return 2
    return 1

def l2s(L,sep='>'):
    """Converts list to string, > default separator"""
    os=''
    for x in L[:-1]:
        os=os+str(x)+sep
    os=os+str(I(L,-1))
    return os

def a2s(a,sep='>'):
    """Converts any to string, > and \n default seps"""
    if lty(a)<2:
        return str(a) if lty(a)==0 else l2s(a,sep)
    s=''
    for b in a:
        s=s+(str(b) if lty(b)==0 else l2s(b,sep))+'\n'
    return s

def a2p(a):
    """If list or tuple, returns tuple. Else returns 1-tuple."""
    return tuple(a) if lty(a)>0 else (a,)

def a2pp(a):
    """Makes tuple of tuples"""
    if lty(a)<2:
        return (a2p(a),)
    pp=()
    for b in a:
        pp=pp+(a2p(b),)
    return pp

def a2l(a,seps='>'):
    """Converts any to list, > default sep (can be alternative seps)"""
    if lty(a)>0:
        return list(a)
    s=str(a)
    if I(s,-1)=='\n' and '\n' in seps:
        s=s[:-1]
    if s=='' and '>' not in seps:
        return []
    l=[]; t=''
    for ch in s:
        if ch in seps:
            l.append(t); t=''
        else:
            t=t+ch
    l.append(t)
    return l

def a2ll(a,seps='>'):
    """Converts to list of lists, > and \n default separators"""
    if lty(a)>1:
        return list(a)
    LL=[]
    for k in a2l(a,'\n'):
        LL.append(a2l(k,seps))
    return LL

def reesc(st):
    """Escapes string to regex or removes initial !R"""
    import re; s=str(st)
    return s[2:] if re.match('!R',s) else re.escape(s)

def a2re(a,get=0):
    """String/tuple to regex: init. !R for no escape, get=1 for ()"""
    os='(' if get else '(?:'; p=a2p(a)
    if len(p)==1:
        return '('+reesc(p[0])+')' if get else reesc(p[0])
    for x in p:
        os=os+reesc(x)+'|'
    return os[:-1]+')'

def mgps(r,s):
    """Returns all matched groups from regex matched to s, or []"""
    ol=[]; import re
    l=re.search(r,s)
    if not l:
        return []
    for x in l.groups():
        if type(x)==str:
            ol.append(x)
    return ol

def mgp(r,s):
    """First of matched groups, or '' """
    return I(mgps(r,s),0)

def newunifile(finame,intro=''):
    """Creates unicode file with intro as first line, if file nonexistent"""
    """Returns 1 if created, else -1"""
    full=finame if '.' in finame else finame+'.txt'
    try:
        fi=open(full)
    except:
        try:
            nf=open(full,'w')
        except:
            return -1
        nf.write('\xef\xbb\xbf'+(intro if intro!='' else finame+' file')+'\n')
        nf.close()
        return 1
    fi.close()
    return -1

def fi2l(finame):
    """Gets list of lines; returns -1 if no such file"""
    L=[]; fo=finame if 'log' in finame or '/' in finame or\
       '.' in finame else 'jdata/'+finame
    full=fo if '.' in fo else fo+'.txt'
    try:
        fi=open(full)
    except:
        return -1
    for line in fi:
        L.append(line[:-1] if I(line,-1)=='\n' else line)
    fi.close()
    return L[1:]

def fi2ll(finame,seps='>'):
    """File with >-sep. lines to list of lists. -1 if no such file"""
    a=fi2l(finame)
    return -1 if a==-1 else a2ll(a,seps)

def F(*fis):
    """Multiple fi2ll"""
    j=()
    for fi in fis:
        j=j+(fi2ll(fi),)
    return j[0] if len(j)==1 else j

def fi2s(finame):
    """Converts file to single string with \n's. -1 if no such file"""
    a=fi2l(finame)
    return -1 if a==-1 else l2s(a,'\n')+'\n'

def a2fi(A,finame):
    """Writes anything to file"""
    if A=='':
        return
    full=finame if '.' in finame else finame+'.txt'
    fi=open(full,'a')
    for L in a2pp(A):
        fi.write(l2s(L)+'\n')
    fi.close()
    return 0

def log(*f):
    """Logs g_logcon plus series of items, to g_logfile"""
    op=(g_logcon,) if g_logcon else ()
    for a in f:
        op=op+(a2s(a),)
    return a2fi(op,g_logfile)

def allin(a,b):
    """?Are all chars/els of a in b"""
    for x in a:
        if x not in b:
            return False
    return True

def reps(L,M=0):
    """List of repetitions in L / things in L also in M"""
    OL=[]
    for i in range(len(L)):
        if L[i] in (M if M!=0 else L[:i]):
            OL.append(L[i])
    return OL

def replaces(st,L):
    """Does non-reiterated replaces acc. to list of pairs"""
    for ab in L:
        st=st.replace(ab[0],ab[1])
    return st

def subs(st,L):
    """Applies list of regex substitution pairs (triples)"""
    import re
    for l in L:
        st=re.sub(l[0],l[1],st,I(l,2,0))
    return st

def has(S,st,wh=0,se=''):
    """?Does S contain a(any of) st (can be !R+regex) (se for start/end)"""
    """If wh>0: +which(2=last non-overlap.)+start+stop(3=how many)"""
    import re; of=0; s=str(S); r=a2re(st,1)
    if wh>1:
        M=re.split(r,s)
        if len(M)>1:
            of=len(s)-len(M[-1])-len(M[-2]); s=s[of:]
    m=re.search(('^' if 's' in se else '')+r+('$' if 'e' in se else ''),s)
    if wh==0:
        return True if m else False
    if m:
        return True, m.group(), m.start()+of, m.end()+of if wh<3 else len(M)/2
    return False,'',-1,0

def starts(S,st,wh=0):
    """?Does S start with (any of) st (wh=1 also returns which)"""
    return has(S,st,wh,'s')

def ends(S,st,wh=0):
    """?Does S end with (any of) st (wh=1 also returns which)"""
    return has(S,st,wh,'e')

def isas(S,st,wh=0):
    """?Is S (any of) st (wh=1 also returns which)"""
    return has(S,st,wh,'se')

def spl(S,st):
    """Split: if st in S, returns triple, else S,'',''"""
    h=has(S,st,1)
    return (S[:h[2]],h[1],S[h[3]:]) if h[0] else (S,'','')

def mspl(sl,r,ch):
    """Splits 1st of strings; codes the result (code is !;(ch)(n); )"""
    import re
    m=re.split('('+r+')',sl[0]); os=''
    for n in range(len(m)):
        if n%2==0:
            os=os+m[n]
        else:
            sl.append(m[n]); os=os+'!;'+ch+str(len(sl)-1)+';'
    return [os]+sl[1:]

def subslist(sl):
    """List for subs use based on sl"""
    L=[]
    for n in range(1,len(sl)):
        L.append([r'!;[^0-9]*'+str(n)+';',sl[n]])
    return L
        
def sf(S,m,st='',fl=''):
    """Finds st in S (or rel. index m), fl=j,l,1. -1 if m=-1 or not found"""
    if type(m)!=int:
        fl=st; st=m; m=0
    if m<0:
        return (-1,'') if '1' in fl else -1
    K=has(S[m:],st,(2 if 'l' in fl else 1))
    if not K[0]:
        return (-1,'') if '1' in fl else -1
    i=K[3] if 'j' in fl else K[2]
    return (i+m,K[1]) if '1' in fl else i+m

def nin(S,st):
    """How many of (non-overlapping) (any of) st in S"""
    N=0
    if type(S)!=str:
        for s in S:
            if isas(s,st):
                N=N+1
        return N
    return has(S,st,3)[3]

def compare(a,b):
    """If a, b not identical, returns index and differing items""" 
    for n in range(max(len(a),len(b))):
        if I(a,n)!=I(b,n):
            return n,I(a,n),I(b,n)
    return -1,'',''

def envirs(S,st,back,forth):
    """Returns all environments (back and forth define how big) of st in S"""
    L=[]
    for i in range(len(S)):
        si,wh=starts(S[i:],st,1)[:2]
        if si:
            L.append(S[max(0,i-back):i+len(wh)+forth])
    return a2s(L).replace('\n','&')

def per(ST,PARM,THIS):
    """Applies st (column of THIS, -1 gives PARM; or eval string)"""
    if ST==-1:
        return PARM
    if ST==-2:
        return THIS
    if type(ST)==int:
        return I(a2p(THIS),ST)
    return eval(ST.replace('!!','THIS').replace('!%','PARM'))
                
def rows(L,st,col=0,rcols=-2,ret=-1):
    """Gets rcols (-2=all, -1=ind.) of ret (-1=all,0=NOT) rows: st match col"""
    """col can be eval string. Single rcol will debracket"""
    OL=[]; n=0
    while n<len(L) and (ret<1 or len(OL)<ret):
        K=L[n]
        if isas(per(col,n,K),st)==(ret!=0):
            O=[]
            for c in a2p(rcols):
                O=O+(list(a2p(K)) if c==-2 else [per(c,n,K)])
            OL.append(O[0] if type(rcols)==int and rcols>-2 or
                      type(L[n]) not in (list,tuple) and rcols==-2 else O)
        n=n+1
    return OL

def row(L,st,col=0,rcols=-2):
    """First of rows, or []"""
    return I(rows(L,st,col,rcols,1),0,[])

def lf(L,st,col=0):
    """Index of first of rows, or -1"""
    return I(rows(L,st,col,-1,1),0,-1)

def col(L,col):
    """Column(s) from L"""
    return rows(L,'a','"a"',col)

def j2J(st,no=0):
    """All to uppercase; no=1 means only initial"""
    inil=1
    L=[('a','A'),('b','B'),('c','C'),('d','D'),('e','E'),('f','F'),('g','G'),
       ('h','H'),('i','I'),('j','J'),('k','K'),('l','L'),('m','M'),('n','N'),
       ('o','O'),('p','P'),('q','Q'),('r','R'),('s','S'),('t','T'),('u','U'),
       ('v','V'),('w','W'),('x','X'),('y','Y'),('z','Z')]
    for k in g_uni:
        for a in k[1]:
            L.append((a[0],a[1]))
            inil=len(a[0]) if st[:len(a[0])]==a[0] else inil
    if no==1:
        return replaces(st[:inil],L)+st[inil:]
    return replaces(st,L)

def st2St(st):
    """Capitalises first character of string"""
    return j2J(st,1)
            
def J2j(st,no=0):
    """All to lower case; no=1 means only initial"""
    inil=1
    L=[('A','a'),('B','b'),('C','c'),('D','d'),('E','e'),('F','f'),('G','g'),
       ('H','h'),('I','i'),('J','j'),('K','k'),('L','l'),('M','m'),('N','n'),
       ('O','o'),('P','p'),('Q','q'),('R','r'),('S','s'),('T','t'),('U','u'),
       ('V','v'),('W','w'),('X','x'),('Y','y'),('Z','z')]
    for k in g_uni:
        for a in k[1]:
            L.append((a[1],a[0]))
            inil=len(a[1]) if st[:len(a[1])]==a[1] else inil
    if no==1:
        return replaces(st[:inil],L)+st[inil:]
    return replaces(st,L)

def St2st(st):
    """Makes first char. lower case"""
    return J2j(st,1)

def U(st,la=''):
    """From x+ format to Unicode"""
    la=la if la!='' else g_lang; d=row(g_uni,la,0,1)
    for a in d:
        st=st.replace(a[2]+'+',a[0]).replace(j2J(a[2])+'+',a[1])
    return st

def rom(st,la=''):
    """Unicode to reduced format"""
    la=la if la!='' else g_lang; d=row(g_uni,la,0,1)
    for a in d:
        r=I(a,3,a[2])
        st=st.replace(a[0],r).replace(a[1],j2J(r))
    return st  

def rplus(st,la=''):
    """Unicode to x+ format"""
    la=la if la!='' else g_lang; d=row(g_uni,la,0,1)
    for a in d:
        st=st.replace(a[0],a[2]+'+').replace(a[1],j2J(a[2])+'+')
    return st  

def notrail(s,a):
    """Removes (any of) a from end of string, iteratively"""
    t=''; import re
    while ends(s,a) and t!=s:
        t=s; s=re.sub(a2re(a)+'$','',s)
    return s
    
def noinit(s,a):
    """Removes (any of) a from start of string, iteratively"""
    t=''; import re
    while starts(s,a) and t!=s:
        t=s; s=re.sub('^'+a2re(a),'',s)
    return s

def noex(st):
    """Removes spaces and newlines from start and end"""
    return notrail(noinit(st,(' ','\n')),(' ','\n'))

def repblank(t):
    """Removes double blank lines from t"""
    while '\n\n\n' in t:
        t=t.replace('\n\n\n','\n\n')
    return t

def upto(s,a):
    """If s contains (any of) a, returns noex of what goes before (else s)"""
    return noex(spl(s,a)[0])

def after(s,a):
    """If s contains a, returns what comes after (else '')"""
    return spl(s,a)[2]

def insbef(s,a,t,T0='',T2=''):
    """puts t before a in s, T0/T2 logged if not found/found twice"""
    K=has(s,a,1)
    if not K[0]:
        log(T0) if T0!='' else ''; return s
    if has(s[K[3]:],a):
        log(T2) if T2!='' else ''
    return s[:K[2]]+t+s[K[2]:]

def insaft(s,a,t,T0='',T2=''):
    """puts t after a in s, T0/T2 logged if not found/found twice"""
    K=has(s,a,1)
    if not K[0]:
        log(T0) if T0!='' else ''; return s
    if has(s[K[3]:],a):
        log(T2) if T2!='' else ''
    return s[:K[3]]+t+s[K[3]:]

def l2txt(L,sep=', ',lsep=', and ',osep=' and ',do=0):
    """Makes a text list. Normal separator, last, only, operation on items"""
    os=''; k=len(L)
    for n in range(k):
        os=os+per(do,n,L[n])+\
            (osep if n==0 and k==2 else (lsep if n==k-2 else (sep if
                                                            n<k-1 else '')))
    return os

def isn(st):
    """Is st a pure integer?"""
    return isas(st,r'!R0|\-?[1-9][0-9]*') 

def isnin(st,a,b):
    """Is st a pure int in the range a to b?"""
    return isn(st) and eval(st)>=a and eval(st)<=b

def isx(st):
    """Is st a pure English int or decimal?"""
    return isas(st,r'!R\-?(0|[1-9][0-9]*)(\.[0-9]+)?')

def no0(s):
    """Removes redundant initial zero from number"""
    return s[1:] if I(s,0)=='0' and I(s,1,'X') in '0123456789' else s

def nco(s):
    """Puts commmas into English number string"""
    z=spl(s,'.'); import re
    return re.sub(r'(?<=[0-9])([0-9]{3})(?=([0-9]{3})*$)',r',\1',
                  z[0])+z[1]+z[2]

def sround(xs,n=0):
    """Rounds a string number to n dec places, 0 gives an int"""
    z=spl(xs,'.')
    if not isx(xs) or len(z[2])<=n:
        return xs
    if z[2][n] in '01234':
        az='0' if z[0]=='-0' and z[2][:n]=='0'*n else z[0]
        return az+('.' +z[2][:n] if n>0 else '')
    zz=str(eval('1'+z[2][:n])+1)
    if zz[0]=='1':
        return z[0]+('.'+zz[1:] if n>0 else '')
    return str(eval(z[0])+(-1 if z[0][0]=='-' else 1))+\
           ('.'+zz[1:] if n>0 else '')

def nword(nn):
    """Converts to a word if integer 1-9, else just to a string"""
    n=eval(nn) if type(nn)==str and isn(nn) else nn
    if n in range(1,10):
        return ['one','two','three','four','five','six','seven','eight',
                    'nine'][n-1]
    return str(n)
    
def ifpl(n,plst='s',sst=''):
    """returns s or other pl if n not 1, else empty or other sing"""
    return sst if n==1 else plst

def less(x,y):
    """?Is x less than y (nos. by value then strings wo diacritics)"""
    x=eval(x) if type(x)==str and isx(x) else x
    y=eval(y) if type(y)==str and isx(y) else y
    if type(y)==str and type(x)!=str:
        return True
    if type(x)==str and type(y)!=str:
        return False
    if type(y)!=str:
        return x<y
    a=rom(x); b=rom(y); c=J2j(a); d=J2j(b)
    if a==b:
        return x<y
    if c==d:
        return a<b
    return c<d

def lless(p,q):
    """?Is list p less than q"""
    p=a2p(p); q=a2p(q)
    for n in range(max(len(p),len(q))):
        if n==len(p):
            return True
        if n==len(q):
            return False
        if less(p[n],q[n]):
            return True
        if less(q[n],p[n]):
            return False
    return False

def rless(p,q,col=-2,m=0,n=0):
    """?Is p less than q by col (m and n: params if col an eval str"""
    return lless(per(col,m,p),per(col,n,q))

def ins(L,p,col=-2,cp=-2):
    """Inserts p (changed per cp) in list, in order defined by col"""
    m=0; n=len(L); p=per(cp,0,p)
    while m!=n:
        h=(m+n)/2
        if rless(p,L[h],col):
            n=h
        else:
            m=h+1
    return L[:n]+[p]+L[n:]

def sort(L,col=-2,cp=-2,topn=0):
    """Returns cp-ed list of lists/tuples sorted by columns cs (top n only)"""
    OL=[]; n=len(L) if topn==0 else topn
    for p in L:
        OL=ins(OL,p,col)[:n]
    return OL

def getnos(s,decpts='.,'): #must be some decpts
    """Returns normed nos; number blocks; intervening blocks (ie 1 more)"""
    import re
    t=re.split(r'((?:[0-9]|['+reesc(decpts)+'](?=[0-9]))+)',s)
    p=rows(t,'1','str(!%%2)'); q=rows(t,'0','str(!%%2)'); k=[]
    for x in p:
        x=no0(x.replace(',','.'))
        if isx(x):
            k.append(x)
    return k,p,q

def normno(st,u,v,U,V,tolog=''):
    """norms a number string (or ''), w warning + error limits"""
    s=replaces(st,[('&nbsp;',' '),("'",' '),(' ,',' ;'),(' ','')])
    k=sf(s,('(','<','{','['))
    if k>0:
        s=noex(s[:k]); log('*'+tolog+' from '+st+' to: '+s)
    if s=='':
        return ''
    k=sf(s,',')
    if k>0:
        if '.' in s:
            s=s[:k].replace('.','')+'.'+s[k+1:]
            log('*'+tolog+' from '+st+' to: '+s)
        else:
            s=s[:k]+'.'+s[k+1:]
    if not isx(s):
        log('**'+tolog+' NOT NUMERICAL: '+st); return ''
    d=eval(s)
    if d<U or d>V:
        log('**'+tolog+' OUT OF RANGE: '+s+' ('+str(U)+','+str(V)+')')
        return ''
    if d<u or d>v:
        log('*'+tolog+' outside range?: '+s+' ('+str(u)+','+str(v)+')')
    if str(d)!=s:
        log('*'+tolog+' from: '+st+' got '+s)
    return s

def ascoo(s):
    """Converts string/list to six-coo string, or err/warn"""
    p=getnos(a2s(upto(s,('E|','source'))))[0]; g=row(g_coo,g_lang,0,1)
    if len(p)==2 and '.' in p[0] and '.' in p[1]:
            x=eval(p[0]); m=int(x); mm=int((x-m)*60.0+0.5)
            y=eval(p[1]); n=int(y); nn=int((y-n)*60.0+0.5)
            r=[str(m),str(mm),'',str(n),str(nn),'']
    elif len(p)==4 and '.' not in p[0]+p[2]:
        r=[str(p[0]),sround(str(p[1])),'',str(p[2]),sround(str(p[3])),'']
    elif len(p)==6 and '.' not in p[0]+p[1]+p[3]+p[4]:
        r=[str(p[0]),str(p[1]),sround(str(p[2])),
           str(p[3]),str(p[4]),sround(str(p[5]))]
    else:
        #log('**no coords from: '+s)
        return '|||||'
    for i in (2,5,1,4):
        if r[i]=='60':
            #log('*60 in coords: '+s)
            r[i]='0'; r[i-1]=str(eval(r[i-1])+1)
    if eval(r[0]) not in range(g[0],g[1]+1) or \
       eval(r[3]) not in range(g[2],g[3]+1) or \
       eval(r[1]) not in range(0,60) or eval(r[4]) not in range(0,60) or \
       r[2]!='' and eval(r[2]) not in range(0,60) or \
       r[5]!='' and eval(r[5]) not in range(0,60):
        log('**strange coords from: '+s)
        return '|||||'
    return a2s(r,'|')

def coo2xy(c):
    """Pipe-sep coor string to decimals or 0,0"""
    d=[]
    for k in a2l(c,'|'):
        d.append(0 if k=='' else eval(k))
    return d[0]+d[1]/60.0+d[2]/3600.0,d[3]+d[4]/60.0+d[5]/3600.0

def kmdir(x,y,X,Y):
    """Returns distance and direction of (x,y) from (X,Y) (within Poland)"""
    import math    
    vx=(x-X)*110.946
    vy=(y-Y)*111.319*math.cos(math.radians((x+X)/2))
    d=int(math.sqrt(vx*vx+vy*vy))+1
    if vx>2.42*abs(vy):
	pt='north'
    elif -vx>2.42*abs(vy):
	pt='south'
    elif vy>2.42*abs(vx):
	pt='east'
    elif -vy>2.42*abs(vx):
	pt='west'
    else:
	pta='north' if vx>0 else 'south'
	ptb='east' if vy>0 else 'west'
	pt=pta+'-'+ptb
    return d,pt

def km(c,d):
    """Distance between coord | strings"""
    x,y=coo2xy(c); X,Y=coo2xy(d)
    return kmdir(x,y,X,Y)[0]

def kmtxt(dc,dcb,u,v,U,V,abbr,tolog):
    """Makes text e.g. 8 km north, of dc from dcb (warning/error limits)"""
    x,y=coo2xy(dc); X,Y=coo2xy(dcb)
    d,pt=kmdir(x,y,X,Y)
    if d<U or d>V:
        log('**'+tolog+' DIST REJECTED: '+str(d)+' ('+str(U)+','+str(V)+')')
        return ''
    if d<u or d>v:
        log('*'+tolog+' distance wrong?: '+str(d)+' ('+str(u)+','+str(v)+')')
    return '{{convert|'+str(d)+'|km|mi|0'+('|abbr=on' if abbr else '')+'}} '+pt

def loctxts(name,c,*p):
    """Full text: name, coords, list of coo/name/text/uvUV/pri 8s (V2 16s)"""
    L=[]; M=[]; N=[]
    for x in p:
        if len(x)==16:
            A1=km(c,x[0]); A2=km(c,x[8])
            A3=km(x[0],x[8]); Ah=max(A1,A2); Ab=min(A1,A2)
            X1,X2=(x[:8],x[8:]) if Ab==A1 else (x[8:],x[:8])
            L=L+[X1] if 2*(Ah*Ah-Ab*Ab)>A3*A3 else L+[X1,X2]
        else:
            L.append(x)
    for K in L:
        if list(K)==sort(rows(L,K[1],1),7)[-1] and K[1]!=name:
            M.append(K)
    for K in M:
        t=kmtxt(c,K[0],K[3],K[4],K[5],K[6],K!=M[0],K[7])
        if t=='':
            return ''
        if not starts(t,'{{convert|1|'):
            N.append(t+' of '+K[2])
        else:
            log('*omitted: '+t+' of '+K[2])
    returnstr='approximately '+l2txt(N)
    return returnstr if len(N)>0 else ''

def st2date(s):
    """Converts string to proper date"""
    w=getnos(s,'@')[0]
    if len(w)==1 and isn(w[0]) and eval(w[0]) in range (2000,2010):
        return w[0]
    if len(w)==3 and isn(w[2]) and eval(w[2]) in range (2000,2010) and\
        isn(w[1]) and eval(w[1]) in range(1,13) and\
       isn(w[0]) and eval(w[0]) in range(1,30 if w[1]=='2' else (31 if
                    w[1] in ('4','6','9','11') else 32)):
        return w[0]+'&nbsp;'+('January','February','March','April','May','June',
                         'July','August','September','October','November',
                         'December')[eval(w[1])-1]+' '+w[2]
    return ''
    
def urlread(url,tries=50):
    """Gets url text"""
    import urllib
    n=0
    while n<tries:
        try:
            ur=urllib.urlopen(url)
            r=ur.read(); ur.close()
            return r
        except:
            n=n+1
    return 0/0

def wpraw(la,Art):
    return urlread('http://'+la+'.wikipedia.org/w/index.php?title='
                              +Art.replace(' ','_')+'&action=raw')

def wcraw(Art):
    return urlread('http://commons.wikimedia.org/w/index.php?title='+
                      Art.replace(' ','_')+'&action=raw')

def catcont(la,cat):
    """Returns subcats, members, subckeys, membkeys, sdates, mdates (->500)"""
    import re; login(la); SC=[]; M=[]; SCK=[]; MK=[]; SCD=[]; MD=[]
    xm=urlread('http://'+la+'.wikipedia.org/w/api.php?cmtitle=Category:'
        +cat.replace(' ','_')+'&action=query&list=categorymembers'+
        '&cmlimit=500&cmprop=title|sortkey|timestamp')
    rg=r'title=\&quot;(.*?)\&quot;.*?sortkey=\&quot;(.*?)\&quot;.*?'+\
        r'timestamp=\&quot;(.*?)\&quot;'
    for m in re.findall(rg,xm):
        if starts(m[0],'Category:'):
            SC.append(m[0][9:]); SCK.append(m[1]); SCD.append(m[2])
        else:
            M.append(m[0]); MK.append(m[1]); MD.append(m[2])
    return SC,M,SCK,MK,SCD,MD

def fullcatcont(la,cat,d=5):
    """Returns all pages below a cat to a depth of d, +cats they're in"""
    cs=[[cat,'0']]; ps=[]
    for k in range(d+1):
        for c in rows(cs,str(k),1,0):
            a,b,w,x,y,z=catcont(la,c)
            for p in b:
                u=lf(ps,p,0)
                if u<0:
                    ps.append([p,c])
                else:
                    ps[u].append(c)
            for s in a:
                if s not in col(cs,0):
                    if k<d:
                        cs.append([s,str(k+1)])
                    else:
                        ps.append(['Category:'+s,c])
    log([[cat,d]]+ps)
    return

def coca():
    """Investigate unmatched categories"""
    c=F('colog')[0]
    for a in c:
        x=catsin(wpraw('en',a)); y=catsin(wpraw('en','Category:'+a))
        os=''; ns=''
        for p in y:
            if p not in x:
                if 's ' in p+' ':
                    os=os+'[[Category:'+p+']]\n'
                else:
                    ns=ns+p+','
        log('\n'+a+' ('+ns+')\n'+os)
    return 9

def isim(name):
    """?Is ready-trimmed name an image in commons or wp"""
    if '.' not in name[1:-1] or sf(name,list('[]{}<>#|'))>-1:
        return False
    return wcraw('Image:'+name)!='' or wpraw('en','Image:'+name)!=''

def IFim(name):
    """Name if image (or Image: etc.), else empty"""
    if isim(name):
        return name
    if isim(after(name,':')):
        return after(name,':')
    return ''

def nocomm(text):
    """Removes comments from wikipedia text"""
    return subs(text,[(r'\<!--(?:.|\n)*?--\>','')])

def nam(st):
    """Main name part of string, less tag"""
    return upto(st,(',','('))

def tag(st):
    """Tag after comma or in brackets"""
    return mgp(r', (.*)|\((.*)\)',st)

def essnam(st):
    """Removes generic part of name"""
    p=(' ','Gmina','Wojew\xC3\xB3dztwo','Powiat','Park Narodowy',
         'Park Krajobrazowy','Okres')
    q=(' ','County','Voivodeship','National Park','Landscape Park',
         'Park Narodowy','Park Krajobrazowy','District','Region',' kraj')
    return notrail(noinit(nam(st),p),q)

def wpl(st):
    """Make WP (piped) link, not displaying the tag"""
    name=nam(st)
    return '[['+st+']]' if name==st else '[['+st+'|'+name+']]'

def essl(st):
    """Make WP (piped) link, not displaying the tag"""
    name=essnam(st)
    return '[['+st+']]' if name==st else '[['+st+'|'+name+']]'

def Title(na):
    """Makes WP title, w capital and no underscores"""
    return st2St(noex(na.replace('_',' ')))

def targlabel(link):
    """The _T_arget and display text of first wp link (removes extr spaces)"""
    m=mgps(r'\[\[(.+?)(?:\|(.*?))?\]\]',link)
    if len(m)==0:
        return '',link
    return Title(m[0]),I(m,1,m[0])

def targ(link):
    return targdisp(link)[0]

def label(link):
    return targdisp(link)[1]

def redtarg(txt):
    """redirect target in txt or empty string"""
    m=mgp(r'^[ \n]*\#(?:REDIRECT|redirect|Redirect)[ ]*(\[\[.*\]\])',nocomm(txt))
    return I(m,0)

def targpars(t):
    """Name and list of parameter pairs for a template call"""
    import re; m=re.split('\|',subs(t,[('^\{\{',''),('\}\}$','')])); L=[]; n=1
    if len(m)==0:
        return '',[]
    for x in m[1:]:
        mm=mgps(r'^(?:[ \n]*(.+?)[ \n]*\=)?[ \n]*((?:.|\n)*?)[ \n]*$',x)
        a,b=(mm[0],mm[1]) if len(mm)==2 else (str(n),I(mm,0))
        n=n if len(mm)==2 else n+1
        L=rows(L,a,0,-2,0)+[[a,b]]
    return Title(m[0]),L

def imnam(st):
    """Returns image filename only"""
    st2=noinit(st,(' ','[','Image:','image:','grafika:','Grafika:'))
    st3=noex(upto(st2,('|',']')))
    return st3 if '.' in st3 else ''

def esctext(tx):
    """Converts article text to string structure"""
    sl=[tx]
    sl=mspl(sl,r'\[\[[^\|\[\]\<\>\{\}\n]+(?:\|.*?)?\]\]','\n')
    sl=mspl(sl,r'\[\[(?:Image|image|Grafika|grafika)\:[^\|\[\]\<\>\{\}\n]+'+\
            r'(?:\|(?:.|(?<=!;)\n)*?)?\]\]','\n\n')
    sl=mspl(sl,r'\{\{[ \n]*[^\|\[\]\<\>\{\}\n]+?[ \n]*(?:\|[^\{\}]*?)?\}\}','')
    sl=mspl(sl,r'\{\{[ \n]*[^\|\[\]\<\>\{\}\n]+?[ \n]*(?:\|(?:.|\n)*?)?\}\}','')
    return sl

def ansl(sl):
    """Gets lists of links/templates/f values from string structure"""
    LL=[]; LT=[]; LF=[]; u=subslist(sl)
    for s in sl[1:]:
        if I(s,0)=='[':
            Q=targlabel(s); LL.append((subs(Q[0],u),subs(Q[1],u),subs(s,u)))
        else:
            Q,QL=targpars(s); LT.append((Q,subs(s,u)))
            for p in QL:
                LF.append((Q,p[0],subs(p[1],u)))
    return LL,LT,LF

def ant(t):
    """Links (targ,lab,tx), templates (targ,tx), fvals (tem,f,val,tx)"""
    return ansl(esctext(t))

def catsin(tx):
    """All categories explicitly in tx"""
    k=sf(tx,('[[Category:','[[category:'))
    if k<0:
        return []
    t=tx[max(0,k-10):]; L=[]
    for a in ant(t)[0]:
        if starts(a[0],'Category:'):
            L.append(a[0][9:])
    return L
    
def iwto(tx,la):
    """Target(s$) of iwlink to language la in tx, else empty"""
    k=sf(tx,'[['+la+':')
    if k<0:
        return ''
    t=tx[max(0,k-10):]
    return I(row(ant(t)[0],'!R'+st2St(la)+':.+',0),0)[3:]

def fv(tx,tem,*f):
    """Named field values"""
    L=[]; fl=rows(ant(tx)[2],tem,0)
    for x in f:
        L.append(I(row(fl,x,1),2))
    return L[0] if len(L)==1 else L

def IPA(st):
    """converts Polish string to IPA representation"""
    import re; s=' '+rplus(st).replace('-',' ')+' '
    if not re.match(r'( [A-PR-UWXZ]?[a-pr-uwxyz\+]+)+ $',s):
        return ''
    s=subs(J2j(s),[(' w ',' w'),(' z ',' z'),('ch','h'),(r'o\+','u'),
    ('ia','Ja'),('ie','Je'),('io','Jo'),('iu','Ju'),
    ('ai','aj'),('ei','ej'),('oi','oj'),('ui','uj'),('au','aL'),
    (r'sJ|s\+|s(?=i)','S'),(r'zJ|x\+|z(?=i)','X'),(r'cJ|c\+|c(?=i)','C'),
    (r'nJ|n\+','N'),(r'z\+','Z'),(r'l\+','L'),(r'a\+','o9'),(r'e\+','e9'),
    ('dZ','B'),('dX','D'),('dz','0'),('sz','T'),('cz','1'),('rz','R'),
    ('9(?=[bp])','m'),('9(?=[tcC1dBD0gk])','n'),('9l','l'),
    ('(?<=[aeiouy])L(?![aeouy])','U'),('(?<=[aeiouy])j(?![aeou])','I'),
                   ('ji|ii','i')])
    L=[]
    for n in range(11):
        L.append(('bd0BDg'[n]+'(?=[ c1CfhkpstTS4])','ptc1Ck'[n]) if n<6 else\
         ('wzZXR'[n-6]+'(?=[ c1CfhkpstTS4])|(?<=[c1CfhkpstTS4])'+'wzZXR'[n-6],
                 'fsTS4'[n-6]))
    for n in range(3):
        s=subs(s,[(' nad ',' na8d')]+L+[('8d','d '),('8t','t ')])
    s=subs(s,[('(((?<= )[^aeiouy ]*|[^aeiouy ]?)([aeiouy][^aeiouy ]*){1,2} )',
               r"'\1"),("([bdfghkpsSTtwzZX])'(?=[rR4])",r"'\1"),
              ("([bfghkpsSTwzZX])'(?=[lL])",r"'\1"),
              ("([^aeiouy ])'(?=[J])",r"'\1")])
    s=s.replace("'",'') if nin(s,"'")==1 and nin(s,list('aeiouy'))<2 else s
    s=subs(s,[("'nad ",",nad "),("'nat ",",nat "),('(?<=[SXCDN])e','E'),
        ("n(?='?[kg])",'5'),('(?<=[^kg])J','j'),('o9','A'),('e9|E9','Y')])
    mhl=[(' ','-'),('A',U('a+')),('Y',U('e+')),('B',U('dz+')),('C',U('c+')),
         ('D',U('dx+')),('E','e' if 'e' in s else 'e1'),('L',U('l+')),
         ('N',U('n+')),('R',U('z+')),('S',U('s+')),('T','sz'),('X',U('x+')),
         ('Z',U('z+')),('0','dz'),('1','cz'),('4','sz'),('5','N')]
    os='{{IPAc-pl|[]|'
    for n in range(1,len(s)-1):
        os=os+I(row(mhl,s[n],0),1,s[n])+'|'
        if n%28==0 and n<len(s)-2:
            os=os[:-1].replace(']','-')+'}}{{IPAc-pl|-]|'
    return os[:-1].replace('[]|','')+'}}'

def countystub(p):
    pp=p if essnam(p) in ('Opole','Lublin') else essnam(p)
    return pp.replace(' ','')+'-geo-stub'

def skey(st):
    """Makes standard category sort key (returns empty if comes to defa)"""
    s=rom(st); os=''; import re
    for a in re.split(r'[^a-zA-Z]+',s):
        os=os+j2J(I(a,0))+J2j(a[1:])+' '
    return noex(os)

def expandtem(s):
    """Expands s"""
    ur0='http://en.wikipedia.org/wiki/Special:ExpandTemplates'
    ht=doreq(ur0,[('contexttitle',''),('input',s),
                  ('removecomments','1'),('generate_xml','0')])
    return mup(mgp(r'id\="output".*\>((?:[ .]*?)\</textarea\>',ht))

#
# BOT
#

def Ne(x,y):
    return x==y or x==y+'\n' or y==x+'\n'

def formv(form,*ns):
    """Find the given value of a named input in an HTML form"""
    L=[]
    for nam in ns:
        L.append(mgp(r'\<[^\>]*(?:name\="'+nam+r'"[^\>]*value\="(.*?)"'+\
                     r'|value\="(.*?)"[^\>]*name\="'+nam+r'")',form))
    return L[0] if len(L)==1 else L       

def mup(html):
    """Marks up &#ref and &ref; chars. in an html string without tags"""
    global MuPsTr; MuPsTr=['']   #output string as 1-list
    import sgmllib
    pa=sgmllib.SGMLParser()
    pa.handle_data=writetoMuPsTr #how to handle input
    pa.feed(html)                #read and handle input
    pa.close()
    return MuPsTr[0]

def writetoMuPsTr(s):
    """Appends a string to sole element of the global list MuPsTr"""
    """Used in mup() as the data handler"""
    MuPsTr[0]=MuPsTr[0]+s
    return

def doreq(url,dl=''):
    """Makes an HTTP request and sends it; supplies and extracts cookies"""
    """Returns the response html content, or 'KBerrKB on failure"""
    """dl is the optional data list (of key/value pairs) for a POST"""
    """The global cookie jar is botjar"""
    import urllib, urllib2, cookielib
    req=urllib2.Request(url)                    #make Request object
    g_jar.add_cookie_header(req)               #add relevant cookies
    req.add_header('User-agent','Agent.Kotbot') #add User Agent header
    if dl!='':
        req.add_data(urllib.urlencode(dl))     #add data (changes type to POST)
    n=0
    while n<50:
        try:
            u=urllib2.urlopen(req)                 #send the request
            g_jar.extract_cookies(u,req)       #extract cookies from response
            html=u.read()                       #get content from response
            u.close()
            return html
        except:                                     #if error, retry
            n=n+1
    return 'KBerrKB'

def php(la):
    """Returns main part of generic php access string to Wikipedia"""
    return 'http://'+la+'.wikipedia.org/w/index.php?title='

def login(la):
    """Initializes global cookiejar, and logs in as the bot"""
    """Languages (las...) can include 'en' and/or 'pl'"""
    import cookielib; global g_jar
    if  g_jar==0:
        g_jar=cookielib.CookieJar()            #makes global cookie jar
    if la not in g_loggedon:
        ur0=php(la)+'Special:Userlogin'
        doreq(ur0)                                    #get login page
        ur1=ur0+'&action=submitlogin&type=login'
        dl1=[('wpName',g_user),('wpPassword',g_pass), 
             ('wpRemember','0'),('wpLoginattempt','Log+in')]
        rt=doreq(ur1,dl1)                        #submit form
        if rt=='KBerrKB':
            log('*FAILEDTOLOGON: '+la)
        else:
            a2fi('\nLOGGEDON: '+la,'botlog'); g_loggedon.append(la)
    return

def edit(la,Art,instr,*params):
    """Edits Wikipedia page according to instruction (and parameters)"""
    """   la is the language code, Art is the page name"""
    """   instr is the instruction (the function 'edit_'instr will be called)"""
    """Confirms if edit made (adds result to return message)"""
    """Botlogs la:Art:message, returns message and any output"""
    global g_logcon; g_logcon=la+':'+Art
    login(la); ur0=php(la)+Art.replace(' ','_')+'&action=edit' #edit page url
    html=doreq(ur0)                        #get edit page
    if html=='KBerrKB':
        log('*NETWORKFAULT1'); return
    if g_user not in html:
        log('*NOTLOGGEDON'); return
    m=mgps(r'name\=\"wpTextbox1\".*?\>((?:.|\n)*?)\<\/textarea\>',html)
    if len(m)==0:
        log('*BADEDITPAGE'); return
    old=mup(m[0])        #existing text or empty string
    FUNC=eval('edit_'+instr)            #function to be called
 #now call the function and get new text, edit summary, message and any output
    newtext,summ,mess=FUNC(la,Art,old,*params)
    if newtext=='':                     #end if no new text provided
        log(mess) if mess!='' else ''; return
    if Ne(newtext,old):
        log('*NEWTEXTSAMEASOLD'); return
 #now make data list (lp) for POST request
    lp=[]; n=sf(html,'id="editform"')  #find edit form
    for a in ['wpSection','wpStarttime','wpEdittime','wpScrolltop',
              'wpEditToken','wpAutoSummary']:
        val=formv(html[n:],a)            #find each named value on form
        lp=lp+[(a,val)]                   #add key/value pair to list
    lp=lp[:4]+[('wpTextbox1',newtext),('wpSummary',summ),
               ('wpSave','Save page')]+lp[4:]
 #now submit the form
    ur1=php(la)+Art.replace(' ','_')+'&action=submit'         #make the url
    htmr=doreq(ur1,lp)                   #submit the POST request, get response
    if htmr=='KBerrKB':
        log('*NETWORKFAULT2'); return
 #check if the edit was successful
    now=wpraw(la,Art)                          #this is the page text now
    conf='[OK]' if Ne(now,newtext) else '[*NOCONFIRM]'
    log(mess,conf) if '*' in mess+conf else a2fi((la,Art,mess,conf),'botlog')
    return 

def qedit(la,Art,instr,*params):
    """As edit, but starts by reading raw"""
    global g_logcon; g_logcon=la+':'+Art
    exi=wpraw(la,Art); FUNC=eval('edit_'+instr)
    newtext,summ,mess=FUNC(la,Art,exi,*params)
    if newtext=='':                     #end if no new text provided
        log(mess) if mess!='' else ''; return
    if Ne(newtext,exi):
        log('*NEWTEXTSAMEASOLD'); return
    login(la); ur0=php(la)+Art.replace(' ','_')+'&action=edit' #edit page url
    html=doreq(ur0)                        #get edit page
    if html=='KBerrKB':
        log('*NETWORKFAULT1'); return
    if g_user not in html:
        log('*NOTLOGGEDON'); return
    m=mgps(r'name\=\"wpTextbox1\".*?\>((?:.|\n)*?)\<\/textarea\>',html)
    if len(m)==0:
        log('*BADEDITPAGE'); return
    old=mup(m[0])                 #get and mark up content of text area
    if not Ne(old,exi):                      
        log('*UNSTABLEPAGE'); return
 #now make data list (lp) for POST request
    lp=[]; n=sf(html,'id="editform"')  #find edit form
    for a in ['wpSection','wpStarttime','wpEdittime','wpScrolltop',
              'wpEditToken','wpAutoSummary']:
        val=formv(html[n:],a)            #find each named value on form
        lp=lp+[(a,val)]                   #add key/value pair to list
    lp=lp[:4]+[('wpTextbox1',newtext),('wpSummary',summ),
               ('wpSave','Save page')]+lp[4:]
 #now submit the form
    ur1=php(la)+Art.replace(' ','_')+'&action=submit'         #make the url
    htmr=doreq(ur1,lp)                   #submit the POST request, get response
    if htmr=='KBerrKB':
        log('*NETWORKFAULT2'); return
 #check if the edit was successful
    now=wpraw(la,Art)                          #this is the page text now
    conf='[OK]' if Ne(now,newtext) else '[*NOCONFIRM]'
    log(mess,conf) if '*' in mess+conf else a2fi((la,Art,mess,conf),'botlog')
    return 

#
# BOT EDIT FUNCTIONS
# Each edit_xx function must take as arguments:
#  la (lang. code), Art (page name), old (old page text or empty), params...
# It must return:
#  new page text (empty=no edit), edit summary, b(ot)log message
# 

def edit_New(la,Art,old,text,summ='bot creating page',suppr='!DUMMY!'):
    """text, summary, list to suppress logging of text if art found"""
    if not Ne(old,''):
        if sf(old,suppr)>-1:
            return '','','*ARTEXISTS('+str(len(old))+')'
        else:
            return '','','*ARTEXISTS('+str(len(old))+') for:\n'+text+'\n'
    return text,summ,'CREATED'

def edit_Force(la,Art,old,text,summ='bot: standardizing'):
    """text, summary"""
    if Ne(old,''):
        log('*HADTOCREATE')
    return text,summ,'HADTOCREATE' if Ne(old,'') else 'REPLACEDARTICLE'

def edit_Subst(la,Art,old,lp,summ='bot: standardizing'):
    """list of replace pairs (or 6ples, with min/max, warn min/max)"""
    t=old
    for p in lp:
        k=nin(old,p[0])
        if k<I(p,2,0) or k>I(p,3,1000):
            print g_logcon, k, I(p,2,0), I(p,3,1000)
            return '','','*WRONGNUMBEROF '+p[0]
        if k<I(p,4,0) or k>I(p,5,1000):
            log(Art+';*NOTE NUMBER OF '+p[0]+':'+str(k))
        t=t.replace(p[0],p[1])
    return t,summ,'REPLACED'