apple

psutilw.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+import psutil
+
+def iter(*w):
+    x,*_=w
+    for p in psutil.process_iter(*w):
+        yield (p,[p.info[f] for f in x])

wr.py

@@ -0,0 +1,1722 @@
+# -*- coding: utf-8 -*-
+##import sys;import os;sys.path.append(os.environ["AlfiPython"]+r"\Mjmoji");from wr import * ;
+##import mlwebOrWeb as ml
+## wardrobe
+
+import sys,os,re
+import shutil
+import inspect
+import time
+import traceback
+import pprint
+import functools
+
+lf= "\n";lff=lf*2;sp="  ";lf2="\n";tab="\t";
+def fpreturn(*_): return _[0]
+def fpre(*_): return _
+pr=print
+tfolder="r:/temp"
+if not os.path.exists(tfolder): tfolder=os.environ["tmp"]
+if "cpa" in os.environ:
+    #ZVCherryPicker=jofn(os.environ["AlfiPython"],"qt","ZVCherryPicker.pyw")
+    cpy=os.path.abspath(__file__+"\\..\\..")
+    cpw=os.path.abspath(__file__+"\\..")
+    T45=os.environ["USERNAME"]
+    cpa=os.environ["cpa"]
+else:
+    cpa=None
+
+class p310:# require version
+    def __getstate__(zl):return #pickle
+def typeint(w):
+    try:
+        int(w)
+        return True
+    except:False
+def typefn(fn,remove=0):
+    if (re.search(r'["*/:<>?\\|]',(fn))):return
+    if (".." in fn):return
+    if len(fn)>255:return
+    try:
+        open(fn,"ab")
+##        if remove: os.remove(fn)
+    except:False
+def fpf(fn,fb="",tail=""):
+    if not typefn(fn):
+        if not fb:
+            f,e=lfn.splitext(fn)
+            fb=f[:200]+e
+        fn=fb
+    if tail: wfdb(fn+"_", putp(1,tail))
+    return fn
+def putp(fl,te):#,*w,**W):
+    import pickle
+    put=pickle.dumps
+##    print(te)
+    if fl==1: te= put(te)
+    if fl==2: te= pickle.loads(te)
+    return te
+def exrange(li,step=2):
+    if len(li)/step < 0: return
+    for x in range(0,len(li)//step):
+        yield li[x*step:x*step+step]
+def pr2(*a,**k): pass;
+oriAB=lambda x: (print(x[:122],lf*2,x[-122:]))
+ppf=pprint.pformat
+def orib(lii, ix=-1,bound=4):
+    "print(li[:4],li[-4:])"
+    if(ix==-1):
+        lambda x: (print(x[:4],lf*2,x[-4:]))
+    else:
+        lio=[lii[ix+n]  for n in list(range(-bound,bound)) if(ix+n>0 and ix+n<len(lii)) ]
+        for v in lio:
+            if(v==lii[ix]):lio[lio.index(v)]="__"+v
+##        lio[ix]="__"+lio[ix]
+        #lio[ix]+=lf
+        print(lfjw(lio))
+def prline(*a,**k):#X/ref
+    f=inspect.currentframe()
+    if(sys.version=='3.1.2 (r312:79149, Mar 21 2010, 00:41:52) [MSC v.1500 32 bit (Intel)]'):
+        no=inspect.currentframe(1)
+    elif(sys.hexversion>=0x030401F0):#'3.4.1 (v3.4.1:c0e311e010fc, May 18 2014, 10:38:22) [MSC v.1600 32 bit (Intel)]'):
+        "c7 3.7.7 64bit -> 3.8.6"
+        fb=f
+        for _ in range(4):
+            print(fb.f_lineno,fb.f_code.co_filename, fb.f_code.co_name)
+            fb=fb.f_back
+            if not fb:
+                break
+##    print(" L-"+str(no),*a,**k)
+def prfl(li):#prFirstLast
+    print(li[0],lf,li[-1]);
+def pren(v):
+    print(list(enumerate(v)))
+
+
+
+
+
+
+
+
+
+
+#mrk1------------file
+def wfdb(filename,te):#writeFileDirectInBinaryMode
+    f = open(filename,"wb")
+    f.write(te)
+def wfdt(filename,te):#text
+    return wfd(filename).t(te)
+def wfdt8L(filename,te):#textUni NewLine Unix Format
+    f = open(filename,"wU",encoding="utf-8")
+    f.write(te)
+def wfd8(fn,te):
+    wfd(fn).w(te,code="utf8",copy=0)
+def afdt(filename,te):#textUni
+    f = open(filename,"a+",encoding="utf-8")
+    f.write(te)
+write8dd=afdt
+afdtu=afdt
+def rfdb(fn):
+    f = open(fn,"rb")
+    te = f.read()
+    return te
+def rfdt(fn):return wfd(fn).r()
+def rfdl(fn):
+    f = open(fn,"r")
+    te = f.readlines()
+    return te
+def rfdv0(fn,codeList=("cp932","utf-16","utf-8","eucjp"),lines=True):
+    for c in codeList:
+        f = open(fn,"r",encoding=c)
+        try:
+            te = f.readlines() if(lines)else f.read()
+            break
+        except UnicodeDecodeError as XP:
+            continue;
+        except UnicodeError as XP:
+            continue;
+    return te
+def rfdlv(fn): return rfdv0(fn)
+def rfdtv(fn): return rfdv0(fn,lines=False)
+def rfdtu(fn):
+    f = open(fn,"r",encoding="utf-8")
+    te = f.read()
+    return te
+def vcs(bte,cs=("utf8","cp932","utf16","eucjp")):
+    for c in cs:
+        try:        return bte.decode(c)
+        except: continue
+class wfd():#clWfd
+    tab="\t"
+    def __init__(zl,fn,region=(),ir=None,lf="\n"):
+        zl.fn=fn
+        zl.code="utf8"
+        zl.lf=lf
+        zl.ir=ir#
+        zl.by=None
+    def readtime(zl,mod=0):
+        zl.ts=(lfn.getatime(zl.fn)+mod, lfn.getmtime(zl.fn)+mod)
+        return zl
+##    def restoretime(zl):
+    def rfdv(zl):return zl.r(cs=("cp932","utf-16","utf-8","eucjp","mbcs"))#noMbcs)
+##    def mem(zl): zl.by=zl.rb(); return zl;
+    def rb(zl): return open(zl.fn,"rb").read()
+    def r(zl,cs=("utf8","cp932","utf16","eucjp"),lines=False,m=0,te=""):
+        if te: e1=te
+        else:
+          with open(zl.fn,"rb") as f:
+            e1 = f.read()
+        for c in cs:
+            try:
+                t1=e1.decode(c)
+                if("\r\n" in t1):
+                    #if(t1.count("\r")!=t1.count("\n")):return 0
+                    zl.lf="\r\n"
+                elif("\n" in t1):zl.lf="\n"
+                elif("\r" in t1):zl.lf="\r"
+                else:#oneline
+                    pass
+                if lines: te=t1.splitlines()
+                else: te=t1
+                #te=te.replace(zl.lf, "\n")
+                zl.code=c
+                break
+            except (UnicodeDecodeError, UnicodeError) as e:
+                zl.lastException=e
+                continue;
+        else:
+            return 0
+        if(zl.ir) and 0:
+            te=zl.lte=findall(zl.ir,te)
+        if m: #chk modified
+            import hashlib
+            zl.mtime=lfn.getmtime(zl.fn)
+            zl.sha=hashlib.sha256(te.encode()).digest()
+        return te
+    def csvr(zl,*aw,lf=None,tab=None,**kw):
+        from io import StringIO
+        return list(csv.reader(StringIO(zl.r()), delimiter=tab or zl.tab))
+    def w8(zl,te): return zl.w(te,code="utf8")
+    def w16(zl,te): return zl.w(te,code="utf_16_LE")
+    def wjis(zl,te): return zl.write8re(zl.fn,te,"cp932")
+    def wrili(zl,li): return zl.w(li,lines=True)
+    def write8re(zl,fn,te,code="",lines=False,copy=True,lf=1,nbase=0,ts=0):
+        if not code: code=zl.code
+        dir = lfnd(fn)
+        if dir: inidi(dir)
+        if(ifexist(fn) and copy):
+            dnRestore=f"{tfolder}/restore"
+            inidi(dnRestore)
+            zl.fnRestore=nxNumFull(dnRestore,"%s"+lfn.split(fn)[1],nZfill=2) if nbase else jofn(dnRestore,cfile(fn)+" "+tp())
+            shutil.copy2(fn,zl.fnRestore)
+##            emove__
+            rmbat(zl.fnRestore)
+##        if(type(te)!=str):return 0
+        if 1:
+            Lf=(zl.lf if lf==1 else lf)
+            t1=jw(Lf,te) if lines else te
+            #no t1=zl.CallBackCaller() if zl.ir else t1
+            e1=t1 if type(t1)==bytes else t1.encode(code)#
+        try:
+            with open(fn, 'wb') as fo:
+                fo.write(e1)
+        except Exception as e:
+            #restore()
+            LastError=e
+            #with open(nxNumFull(r"r:","%s"+os.path.split(fn)[1],nZfill=2), 'wb') as fo:
+            open(r"r:\fail "+tp()+".txt", "wb").write(e1)
+            return 0
+        if ts==1: os.utime(zl.fn, zl.ts)
+##        finally:
+        if 0:
+##            t2=rfdtv(fn)
+            fo=wfd(fn)
+            t2=fo.r(cs=("utf8","utf16","eucjp","cp932"))
+            print(fo.code,t2)
+##            print(fnRestore,t2)
+            #diff()
+        return 1
+##    def write8re(zl,fn,te,*aw,**kw):print("w;",fn,len(te), lf, dif32(zl.r(),te))
+    def w(zl,te,*a,**k):return zl.write8re(zl.fn, te, *a, **k)
+    def t(zl,te,*a,**k):
+        rmbat(zl.fn,rembat="wf t.bat")
+        return zl.write8re(zl.fn, te,copy=False *a, **k)
+    def CallBackCaller(zl):
+        te=zl.r((zl.code,))
+        rnte=""
+        l=0
+        for n,ran in enumerate(zl.lte):#range list.appended(ire.search)
+            rnte+=te[l:ran[0]]
+            rnte+=zl.cb(n)
+            l=ran[1]
+        rnte+=te[l:]
+        return rnte
+def ornkf(byte,cs=("utf8","cp932","utf16","eucjp"),lines=False):
+        return
+        for c in csf:
+            try:
+                t1=e1.decode(c)
+                if("\r\n" in t1):
+                    if(t1.count("\r")!=t1.count("\n")):return 0
+                    zl.lf="\r\n"
+                elif("\n" in t1):zl.lf="\n"
+                elif("\r" in t1):zl.lf="\r"
+                else:#oneline
+                    pass
+                if lines: te=t1.splitlines()
+                else: te=t1.replace(zl.lf, "\n")
+                zl.code=c
+                break
+            except UnicodeDecodeError as XP:
+                continue;
+            except UnicodeError as XP:
+                continue;
+        else:
+            return 0
+##        with open(zl.fn, "rb", encoding=zl.code):
+        return te
+
+
+
+
+
+
+
+
+#----mrk1-----------
+def line():
+    return inspect.currentframe().f_back.f_lineno
+def cmpd(te,tf):#cmpDokomade.Use for comic rename
+    for n in range(999):
+        if te[n] != tf[n]:
+            return n
+def cmpfs(li):
+    "os.path.commonprefix(list)"
+    ip=min(compd(li[0],f) for f in li)
+    return ip
+def wfy(li,ws=5):# windowfy function, window size
+    for n,f in enumerate(li):
+        yield li[n:n+5]
+##def orin(te=" input"):
+##    print(te)
+##    input()
+def owari():
+    print("\nowari:");
+    input("owari:")
+
+
+from argparse import ArgumentParser
+def arx(a=None):#Exe ar
+    parser = ArgumentParser(description="command_error")
+    parser.add_argument("-f",type=str)#,action="store_true")#
+    parser.add_argument("-re",type=str)
+    parser.add_argument("fil",nargs="*")#all other
+    arps=parser.parse_args(a)
+    return arps
+def a2a(li):
+    return jw(" ",('"{}"'.format(f) for f in li))
+def chdir(i0=0):
+    os.chdir(os.path.split(sys.argv[i0])[0])
+class pushd:
+    def __init__(sl,dir):
+        sl.dL=os.getcwd()
+        os.chdir(dir)
+    def __enter__(sl):
+        return 1
+    def __exit__(sl, _type, value, traceback):
+        os.chdir(sl.dL)
+def chdirc(fil=0,idx=1):# mv to z droped file
+    if not fil:fil=sys.argv[1:]
+    if isinstance(fil,(hhwr)): fil=fil.fil
+    if not fil:
+        pr("please drop off the file");input("chdirc()");
+    else:
+        os.chdir(lfnd(fil[0]))
+        return fil
+
+def chdirm():# mv to z file own is in
+    chdirc(args=sys.argv,idx=0)
+
+def cdn(args = sys.argv):#ChDirNakereba 引数があればそのディレクトリに。なければスクリプトの
+    if(len(args) == 1):
+        lena=0;
+    else:
+        lena=1;
+    argf= args[lena]
+    d=re.match(r"(.+(?:\\|/))",argf).group(1)
+    os.chdir(d)
+#    a=input(argf)
+    return args[1:];
+#r:\p\fi.mkv
+#r:\p
+#r:\p #fi
+#fi.
+#fi.mkv
+#.mkv
+#mkv
+def cdir(fn):return lfnd(fn)
+def cdiy(argf):#+yen
+    return argf[:argf.rfind('\\')+1]#fail .-1+1=0 .""
+def cfile(fn):return lfnb(lfn.splitext(fn)[0])
+def cdotc(fn):return lfnb(fn)
+def catsuff(fn,suf):#foo.mkv, mp4 >> foo.mp4
+    tail=fn.rfind('.')
+    if(tail==-1):tail=None
+    fnre=fn[:tail]+"."+suf
+    if(fnre==fn):
+        return "onaji"
+    return fnre
+replaceSuffix=catsuff
+def catpref(fn,prefix):#r:/foo.mkv, info >> infofoo.mkv
+    "#r:/foo.mkv, info >> r:/infofoo.mkv"
+    yenpos=fn.rfind('\\')
+    if(yenpos==-1):
+        fnre=prefix+fn
+    else:
+        fnre=fn[:yenpos]+'\\'+prefix+fn[yenpos+1:]
+    return fnre
+def CatPS(fn,p,s):
+    return catsuff(catpref(fn,p),s)
+jofn=os.path.join
+jw=str.join# joint words
+lfjw=functools.partial(jw, lf)
+_lfn="LibFileName"#="lfn"
+lfn=os.path
+lfnd=lfn.dirname
+lfnb=lfn.basename
+
+
+
+
+
+def da(te):#DefaultArgument
+    fil=sys.argv
+    if(len(fil)==1):
+        tr=te
+    else:
+        tr=fil[1]
+    return tr
+def dq(te):#double quote
+    if(te[0] != '"' or te[-1] != '"'):
+        return '"'+te+'"';
+def orexit(va,vz):
+    if(va==vz):sys.exit();
+def prit(*a):
+    te=jw(" ", [str(f) for f in a])+lf;
+    print("exit-%d "%inspect.currentframe().f_back.f_lineno, end="");
+    print(te, end="");
+    if a[:1]==(1,):input("*")
+    sys.exit();
+prexit=prit
+def chkexit(*a):
+    pass
+def inidi(pdir):
+    if os.path.exists(pdir): return 1
+    else:os.makedirs(pdir); return 0
+def inidir(*dirlist):
+    cwd=os.getcwd()
+    for f in dirlist:
+        assert type(f)==str, "inidir;"
+        #f=os.path.abspath(f)
+        if not f:
+            os.chdir("..")
+            continue
+        p=os.path.split(f)
+        if(p[0]):#"c:\dir\"
+            if not lfn.exists(p[0]):os.makedirs(p[0])
+            assert lfn.isdir(p[0])
+            os.chdir(p[0])
+        if(p[1]):#"c:\file" > ("c:\", "file")
+            if not os.path.exists(f):wfdb(f,b"")
+    os.chdir(cwd)
+##def mkTree(te):
+def isdir(fn):
+    if os.path.isdir(fn): return fn;
+    if os.path.isfile(fn): return 0;
+    if os.path.islink(fn): return 0;
+##    raise Exception("No dir and no file")
+def isBound(length,index):
+    if(length<0):
+        index=abs(index+1)
+    return bool(length>index)
+def boundary(x,b):
+    if b[0]>x:x=b[0];
+    if b[1]<=x:x=b[1]-1
+    return x
+def ifexist(fn):#return True
+    return os.access(fn,os.F_OK)
+##ifExist=ifexist
+def ifImage5(fn):
+    a
+def AbImage1(fs,grouping=False):#連番を表示しない。冗長になるのを防ぐ
+    lioView=[]
+##def AbLine(lii):#elide
+    DiNameTm=puni()
+    for fn in fs:
+        NameTm=re.sub(r"\d","5",fn)
+        DiNameTm.up(NameTm,fn)
+    #
+    ireTailNm=re.compile(r"(\d+)")
+    def fTailNm(fn):#return rearest number
+        fn=re.sub(r"(mp4|mp3)","",fn)
+        mo=ireTailNm.findall(fn)
+        if mo:
+            Nm=int(mo[-1])
+            return Nm
+        return 0
+    if grouping:
+        d2=list((k,sorted(v,key=lambda e: -fTailNm(e))) for k,v in DiNameTm.items())
+        l1=[[" "+f[0]]+f[1:grouping] for k,f in d2]
+        lioView=[f1 for f2 in l1 for f1 in f2]
+    else:
+        lioView=[max(v,key=fTailNm) for k,v in DiNameTm.items()]
+    return lioView
+def orror(*a,**k):
+    te=jw(" ",(str(f)for f in a)) + lf;
+    afdt("orror00.txt",te)
+def orro2(*a,**k):
+    te="";
+    for f in a:
+        ty=type(f);
+        if(ty==int):
+            ti=str(f);
+            te= te+ti
+        else:
+            te+=f;
+        te+=" ";
+    te+=lf;
+    afdt("orror00.txt",te)
+def orro3(fn,te0=None,sp=" "):
+    if(te0!=None):
+        wfd(fn).w(te0,copy=False)
+    def f(*a,**k):
+        te=jw(sp,[str(t) for t in a]);
+        afdt(fn,te+lf)
+        return te
+    return f;
+orro4=orro3(r"r:\orr.txt",sp=';')
+def move2(src,dist, rec=0):
+    if dist==src: return
+    distdir=lfn.dirname(dist)
+    if distdir and not(ifexist(distdir)): os.makedirs(distdir)
+    if rec: afdt("r:\\temp\\rename.txt",dist+tab+src+lf);
+    os.rename(src,dist);
+##def move2(src,dist): move2(dist,src,0)
+
+def rmbat(fns,rembat="rmbat.bat",tmd=tfolder):#jis only
+    rembat=tmd+"/"+rembat
+    if not ifexist(rembat): afdt(rembat, 'chcp 65001\r\n')
+    for fn in fns if type(fns)!=str else [fns]: afdt(rembat,'del "{fn}"\r\n'.format(fn=lfn.abspath(fn)))
+orRemove=rmbat
+def remove(fn,add=1):
+    if not ifexist(fn):return
+    if add: afdt(r"r:\temp\rename.txt",":rm"+"\t"+fn+lf);
+    os.chmod(fn,0o770)
+    if lfn.isdir(fn):
+        shutil.rmtree(fn)
+    elif lfn.isfile(fn):
+        os.remove(fn)
+    return 1
+def remo(fn): return remove(fn,add=0)
+from uuid import uuid1
+def timepref(w=5,n=2):# zero width, after z decimal point
+    return time.strftime("%Y%m%d-%H%M%S")+"-{t:0{w}d}".format(w=w,t=time.perf_counter_ns()//(1000000000//10**n))
+from datetime import datetime
+_now=0
+def tp(te="%Y%m%d-%H%M%S",n=2):#%f
+    global _now
+    while 1:
+        ((now:=datetime.now()))
+        now=now.strftime(te)+"-{}".format(f"{now.microsecond:06}"[:n])
+        if _now!=now:break
+    _now=now
+    return now
+
+def emove(src,timebase=True):
+    src=os.path.abspath(src)
+    c=os.path.splitdrive(src)[0]+os.path.sep #c:
+    emo=jofn(c, "emove______")
+    if not(os.path.exists(emo)): os.makedirs(emo)
+    _id=tp() if timebase else str(uuid1(0))# None . getnode()
+    #base="{} {}".format(os.path.basename(src), _id)
+    base=_id
+    dst=jofn(c, "emove______", base)
+    afdt(jofn(emo,"wrld.txt"),src+"\t"+base+lf);
+    os.rename(src,dst)
+    return dst
+def emrestore(fn="C"):
+    if len(fn)==1:
+        emo=jw(lfn,fn[0]+":/", "emove______")
+    else:emo=fn
+    li=rcsr(jw(lfn,emo,"wrld.txt"))
+    return li
+    return (li[-400:])
+def fripfn(a,b):
+    aff=a+"fripfn"
+    os.rename(a,aff)
+    os.rename(b,a)
+    os.rename(aff,b)
+#emove(r"r:\02zv.txt")
+#2remove
+def ora2i(te):# ascii 2 int
+    return int(jw("",re.findall("\\d+",te)))
+def orsplit1(te,Threshold=1):
+    return [j for j in te.splitlines() if len(j)>=Threshold and j[0]!="#"]
+def orsplit(te,delimiter):
+    t2=te.split(lf)
+    t3=[j.split(delimiter) for j in t2 if len(j) > 0]
+    return t3
+def orsplit2(te,delimiter,threshold=5,strip=fpreturn):
+    "VzComment"
+    t2=te.splitlines()
+    l1list=[[strip(f) for f in j.split(delimiter)] for j in t2 if len(j)>=threshold and j[0]!="#"]
+    return l1list
+##def orsplit3(te,delimiter):
+##    "VzCommentCsv"
+##    t2=te.split(lf)
+##    l2list=[j.split(delimiter) for j in t2 if j[0]!="#"]
+##    return l2list
+def orsub(map0,te):
+    pat=jw("|",map(lambda e:re.escape(e),map0.keys()));
+##    pr(pat);
+    irfinal=re.compile(pat)
+    def f6(mo):
+        mc= mo.group(0);#[0];
+        if (mc in map0):
+            mc=map0[mc];
+        else:
+            raise Exception("orsub");
+        return mc;
+    t2=irfinal.sub(f6,te);
+    return t2;
+def orsubne(map0,te):#NonEscape
+    pat=jw("|",map0.keys());
+##    pr(pat);
+    irfinal=re.compile(pat)
+##    mapi={orsub({r"\[":"[",r"\]":"]",r"^":"","$":""},k):v for k,v in map0.items()}
+    def f6(mo):
+        mc= mo.group(0);#[0];
+        li=[v for k,v in map0.items() if re.match(k,mc)]
+        if li:pass
+        else:
+            raise Exception("orsubne");
+        return mc;
+    t2=irfinal.sub(f6,te);
+    return t2;
+#mo.expand(r"\1.mp4")
+#
+def findall(ire,te,rebuild=0):
+    ire=re.compile(*ire) if not isinstance(ire,re.Pattern) else ire
+    ran=(0,0)#range
+    while (234789):
+        mo=ire.search(te,ran[1])
+        if(mo):
+##            print(mo,mo.groups())
+            if rebuild:
+                yield (ran[1],mo.span()[0]), 0
+                yield mo.span(), mo
+            else: yield mo
+            ran=mo.span()
+        else:break
+    else: fwew
+    if rebuild: yield (ran[1], len(te)), 0
+#2regex
+##prexit(findall(re.compile(r"(\d*) (?=<d>\d*)a"),"1 2a"))
+##prexit(findall(re.compile(r"(\d)(?P<d2>2)?"),"123 1 12"))
+##prexit(list(findall((r"('.+?')",),"1'2'3 '1' 12",rebuild=1)))
+def dif1(prefix,pat="#mrk1"):
+    ir1=compilev(pat)
+    mo=ir1.findall(rfdtu(sys.argv[0]))
+    for n,v in enumerate(mo):
+        write8("r:\\"+prefix+"%d%d"%(n,len(v))+".txt",v)
+def dif2(t1,t2):
+    from difflib import HtmlDiff
+    df = HtmlDiff()
+    return df.make_file(t1,t2)
+def charjunk(c):
+    return c==" \t"
+def dif3(t1,t2):
+    import difflib as dif
+    print=orro3(r"r:\tstDiff.txt")
+    print("ndiff\n",lfjw(list(dif.ndiff(t1,t2))))
+    dcd=dif.Differ().compare(t1,t2)
+    print("compare",list(dcd))
+    unif=list(dif.unified_diff(t1,t2))
+    print("unified",lfjw(unif))
+    #wel print("ndiff",list(dif.ndiff(t1,t2,charjunk=charjunk)))
+    con=dif.context_diff(t1,t2)
+    print("context",lfjw(con))
+    ir1=dif.SequenceMatcher(None,t1,t2)
+    print("opcodes ",ir1.ratio(),list(ir1.get_opcodes()))
+    return jw(lf,unif)
+    #
+def dif3tst():
+    import difflib as dif
+    t1="am..==d"
+    t2="pm..i=="
+    l1=list(t1); l2=list(t2)
+    ir1=dif.SequenceMatcher(None,t1,t2)
+    mo=ir1.get_matching_blocks()
+    print(ir1.ratio())#equal==1.0
+    print(lf,t1,lf,t2,lf,  list(mo))
+    print(list(ir1.get_opcodes()))
+    sys.exit()
+def dif4(*T):
+    import difflib as dif
+    return lfjw(list(dif.unified_diff(*[t.splitlines() for t in T]))[2:])
+def dif32(*T): return dif3(*[t.splitlines() for t in T])
+def dif5(t1,t2, splitlines=str.splitlines):
+    import difflib as dif
+    f=(dif.SequenceMatcher(None,*[splitlines(t) for t in (t1,t2)]))
+    return f.get_opcodes()
+qfem="""
+; ;;
+: ;c
+\\ ;y
+/ ;l
+" ;d
+? ;q
+< ;k
+> ;r
+| ;s
+* ;a
+"""#
+q_fileEscapeMap={k:v for k,v in [k.split(" ") for k in qfem.split(lf) if k]}
+##q_fileEscapeMap={";":";;",":":";c","\\":";y","/":";l",'"':";d","?":";q"}
+def esfn(fn):#EscapeFileName;x/2
+    return orsub(q_fileEscapeMap,fn );
+def exfn(fn):#extract
+    return orsub(puni(q_fileEscapeMap).tenchi(),fn);
+time.perf_counter()
+##def clock
+def orbench(p):#BenchMark(Proc)K@milisecond
+    t = time.perf_counter()
+    tsai = time.perf_counter() - t
+    t = time.perf_counter()
+    rn=p()
+    t = time.perf_counter() -t -tsai;
+    return t,rn;
+
+def cbbench(f):
+##    @functools.wraps(f)
+    def cb(*a,**k):
+        timeL=time.perf_counter()
+        rn2=f(*a,**k)
+        rn1=time.perf_counter()-timeL
+        return rn1,rn2
+    return cb
+def timefor(cb,lis,to,start="start",logfile=""):
+    def pr(te): return afdt(logfile or tfolder+"/log for time", te+lf)
+    if start: pr(start)
+    ti2pre=tia0=ti0=time.perf_counter()
+    x9=len(lis)
+    for x1,fn in enumerate(lis):
+        et=cb(x1, fn, pr)
+##    if 1:
+        ti2=time.perf_counter()
+        eli=(ti2-ti0)
+        x1p=x1+1
+        ti9=eli/(x1p) * x9
+        mean=eli/(x1p)
+        one=ti2 - ti2pre
+        ti2pre=ti2
+        remain=ti9-eli
+        if (ti2-tia0) > to[0]:
+            te=et+f"({one:.1f}), {x1p}/{x9} ,  {eli:.1f} / {ti9:.1f}, {remain=:.1f}"
+            print(te)
+            pr(te)
+            tia0=ti2
+        if to[1] and eli > to[1]:return
+        if et=="return": return et
+
+#---------
+class picnic():
+    pass;
+def rnzk(te,li,opt=re.S|re.I):#renzoku
+    for s,d in li:#src dist;
+##        pr(s,"__",d);
+        ir=re.compile(s,opt);#DOTALL|IGNORE ##|re.X=VERBOSE
+        te=ir.sub(d,te);
+    return te
+def rfor(url,li):
+    for l in li:
+        mo=re.match(l[0],url);
+        if mo :return l[1]
+    raise Exception ("no such url");
+def sas(reg,te,bug=False,**kw):
+    teli=[te]
+    #reg=([(re.compile(f[0]),f[1]) for f in f2] for f2 in reg)
+    reg=([re.compile(f,re.S) for f in f2] for f2 in reg)
+    for ix,(ri,rx) in enumerate(reg):
+        li2=[]
+        for ta in teli:
+            #li2.extend([f for f in ri[0].sub(lambda e:ri[0].sub(ri[1],e), ta) if f])
+            li2.extend([f for f in ri.findall(ta) if f])
+        teli=li2
+        if bug: afdt(r"r:\fjpg-sas.txt","mrk{}\n".format(ix)+ppf(teli))
+    return teli
+##class sas():# search and search
+##    def __call__(sl):
+##        for
+if 0:
+##class reg(re):
+  def compile(me,*w):
+    try:
+        return re.compile(*w)
+    except re.error as e:e
+  def sub(me,*w):
+    try:
+        return me.sub(*w)
+    except re.error as e:
+        e
+compilev=lambda e:re.compile(e,re.S|re.I|re.X|re.M)
+compilevs=lambda e:re.compile(e.replace(" ","\\s*"),re.S|re.I)
+compilex=lambda e:re.compile(e.replace(" ","\\s*"),re.S|re.I|re.X)
+compiled=lambda e:re.compile(e,re.S|re.I)
+compilefn=lambda e:re.compile(e,re.I)
+irealpha=re.compile(r"[_\.a-zA-Z0-9]")
+def adcompile(fp):
+    if isinstance(fp,str): return compilevs(fp).search
+    if isinstance(fp,re.Pattern): return fp.search
+    return fp
+
+
+
+#       #-----------
+def tae(p):#TryAndError例外で終了させずに表示する
+    try:
+        p()
+    except Exception as e:
+        orro4(e,lf,e.args,lf,type(e));
+        return(e)
+def t1t(p): return ttt(p,times=1)
+def ttt(p,times=10,interval=4):# try ten times
+    for n in range(times):
+        try:
+            return p()
+        except Exception as e:
+            if n+1 >= times: return e
+            time.sleep(interval)
+            continue
+def cbTry(f,ercb=None,lo=0,ww=()):
+##    flq=1 if hasattr(f, "__self__") and isinstance(f.__self__, orq) else 0
+##    la=lambda e: a[1:]
+    @functools.wraps(f)
+    def cb(*a,**k):
+##        f(*a)
+        try:
+            #return f(**k) if a[flq:] is (False,) else f(*a,**k)
+##            print("cb;", a,f,cb)
+            #return f(**k) if not a[flq:] or a[flq] is False else f(*a,**k)
+            if ww:
+                wwa=ww[0]
+                www=ww[1] if ww[1:] else {}
+                if lo==1:lg("cb", f.__qualname__, a,k,ww)
+                return f(*wwa,**k,**www) if not a or a[0] is False else f(*wwa, *a,**k,**www)#pass
+            if lo==1:lg("cb", f.__qualname__, a,k)
+            return f(**k) if not a or a[0] is False else f(*a,**k)#pass
+        except Exception as e:
+            except2(0,find=1,edit="npp")
+##            e2=except2()
+##            MiniMsg(te)
+            if ercb: cbTry(ercb)(e)
+    return cb
+
+def edipt(te="",find=0,edit=0,fntbl=()):
+    if edit:return except_edit(te,fntbl)
+    pmo=pmobile(2)
+    e2=te or traceback.format_exc()
+    if find:
+        if find=="p":
+##            mo=compiled((r'(?<= File ")(.*?)", line (\d+), in (.+?)\n(.*?)')).findall(e2)
+            mo=compiled((r'(?<= File ")([^\n]+?)", line (\d+)(?:, in )?([^\n]*?)\n((?!  File).*?(?=\n))?')).findall(e2)
+            mo=[[pmo.conf(f) for f in f2] for f2 in mo if not any(((compilex(r"/python|\\Python\\|importlib").search(f2[0])), ("#pass" in f2[-1]) )) ]
+            return (pmo.conf(omiterror(e2)),mo)
+        if 0:
+            mo=re.findall(r'"<string>", line (\d+)(), in <module>\n(.*)',e2)
+            return mo
+    return pmo.conf(omiterror(e2))
+except2=edipt
+def except_edit(te,fntbl):
+    e2=except2(te,find="p")
+    t1=e2[0].splitlines().pop()
+    if "dialog rejected;" in t1: return
+    if "SystemExit" in t1: return
+    from qNote1 import orDialog, iniap, MiniMsg, clhk
+    app=iniap()
+    mono=orDialog()
+    if not e2[1]: return MiniMsg(e2)
+    mo=[clhk(f, teh=(f"({cfile(f[0])}), {f[1]}, {f[2]}, \n{f[3]}")) for f in e2[1]]
+    whw=[mo+[e2[0]]]
+    mono.xch(whw)
+    if not mono.fiFiles:return
+    fn,*_=mono.pickupli()
+    if type(fn)==str:return e2
+    (fn,ln,mod,te)=fn
+    if fn in fntbl: fn=fntbl[fn]
+    print(fn,fntbl)
+    npp(fn,f"-n{ln}")
+    return e2
+def omiterror(e2):
+    return rnzk(e2,(
+("NameError: name",""),
+))
+def mpvstring(e2):
+            #t1=e2.splitlines().pop()
+            e2=re.sub(r'Traceback .+?\n','',e2)
+            e2=re.sub(r'  File "C:\\cpy\\qt\\(?:clas\\)?(.+?)(?:\.pyw?)", line (\d+),',r'"\1",\2',e2)
+            if "mpv property does not exist" in te:
+                if(mo:=re.search(r"'(mpv property does not exist)',.*?b('.*?'),",te)): te=str(mo.groups())
+                else: te="mpv not exist"
+##                te=rnzk(te,(
+##                (r"'(mpv property does not exist)',.*?b('.*?'),",r"\1 \2"),
+##                (r"\d+",""),
+##                ))
+def orpopen(mp3):
+    import subprocess as p
+    p.Popen([mp3],shell=True);
+def orPOA(cmd,shell=True):
+    import subprocess as p
+    p.Popen(cmd,shell=shell);
+##orPOA(r'start cmd /c "r:\c f.bat"')
+def wiff(w):
+    orPOA([ordiMdirs()["wiff"],*w])
+def npp(*w):
+    if not w: return ordiMdirs()["npp"]
+    orPOA([ordiMdirs()["npp"],*w])
+def nppw(lis,fn=tfolder+"/log"):
+    wfd(fn).t(lis)
+    npp(fn)
+def AltEdit():
+    import altEdit
+    altEdit.scroll()
+def AltEditSpyder():
+    import altEdit
+    altEdit.PyScripter=r"E:\Python34\Scripts\spyder.bat"
+    altEdit.scroll()
+#
+class puni(dict):
+##    def update(zl,k,v): dict.update(zl,[(k,v)])
+    def ez(zl,k):#di.get()
+        return  zl[k] if(k in zl) else 0;
+    def ud(zl,k,v):
+        zl.update([(k,v)]);
+    def up(zl,k,L):#update append
+        if(k in zl):
+            zl[k].append(L);
+        else:
+            zl.update([(k,[L])]);
+    def uni(zl,k,L):#update append uni
+        if(k in zl and L not in zl[k]):
+            zl[k].append(L);
+        else:
+            zl.update([(k,[L])]);
+    def setclr(zl,li,la):
+        for nc,f in enumerate(li):
+            k=la(f)
+            zl.up(k,f)
+        return zl
+    def ui(zl,k):#updateIncliment
+        zl.ul(k,1)
+    def ul(zl,k,L):#update vz Length
+        if(k in zl):
+            zl[k]+=L;
+        else:
+            zl[k]=L
+    def us(zl,k):#文字ごとの生起確率
+        for c in k:
+            zl.ui(c);
+        return zl;
+##    def counter(zl,w):
+    def Clip(zl,count,regexpattern="."):
+        "Clip key less than count"
+        ire=re.compile(regexpattern)
+        return puni([(k,v) for k,v in zl.items() if(v>count)and(ire.match(k))])
+    def LetterFrequency(zl,te,llen=2):
+        for k in range(len(te)-llen+1):
+            zl.ui(te[k:k+llen])
+        return zl;
+    def ol(zl):#oredered list by value;
+        return [[k,v] for k, v in sorted(zl.items(), key=lambda x:x[1])]
+    def olal(zl):#appended length
+        tl={k:len(v) for k,v in zl.items()}
+        return puni.ol(tl);
+    def ok(zl):#oredered list by key;
+        return [[k,v] for k, v in sorted(zl.items(), key=lambda x:x[0])]
+    def ovk(zl,valuekey):#sort by appended list
+        pass
+    def tenchi(zl):
+        li={v:k for k,v in zl.items()}
+##        li=map(lambda x: x,li);
+        return li;
+        d=puni()
+        for k,v in zl.items():
+            d[v]=k;
+        return d;#X/2
+    def xemj(zl,vn="v"):#moji for exec,Video
+        tef="";
+        for k in zl.keys():
+            tei="%s=%s[%s];"%(k,vn,repr(k));#tei=k+"="++";";
+            tef+=tei;
+        return tef;
+    def rms(zl,la):
+        pops={k:v for k,v in zl.items() if la(k,v)}
+        _=[zl.pop(k) for k in pops]
+        return zl,pops
+    #listDict
+    def lipop(zl,k,cb):
+        for k,v in zl.items():
+            for n,v1 in enumerate(v):
+                if(cb(v1)):return k,n
+    def lipop1(zl,k,te):
+        #{k,[[open,],[file,],[copy,],]};findcopy():lipop(k,"copy")
+        return zl.lipop(k,lambda e: e[0]==te)
+##    def compres(zl,w0,fp=fpreturn,uni=0):
+##        for f in w0:
+##            zl.compresin(f,fp)
+##        return zl
+    def compres(zl,f,fp=fpreturn,uni=0):
+        z2=zl
+        if 1:
+            z2=zl
+            for w in f[:-1]:
+                w=fp(w)
+                if w not in z2: z2[w]=puni()
+                z2=z2[w]
+            z2.ul(f[-1],1)
+            return z2[f[-1]]
+    def flat(zl):
+        li=[((x,),v) for x,v in zl.items()]
+        for p,v in li:
+            if isinstance(v,puni):
+                li.extend(((*p,p2),v2) for p2,v2 in v.items())
+            else:
+                yield (*p,v)
+ordict=puni
+class pini(puni):
+    def __init__(zl,d={},fn="pini00.ini"):
+        dict.__init__(zl,d);
+        zl.fn=fn;
+        if(os.access(fn,os.F_OK)):
+            f=rfdv0(fn,["utf-8"])
+            for j in f:
+                a=j.split("\t");
+##                try:
+##                    nm=float(a[1])
+##                except:
+##                    pass;
+                if(len(a)== 2):
+##                    exete='zl["%s"]=' % a[0]#.replace("\\","\\\\");
+                    exete='zl[%s]=' % a[0]#.replace("\\","\\\\");
+                    et2= exete+a[1];
+                    exec(et2);
+                else:
+                    notTheFormat
+    def save(zl):
+        te="";
+        for k,v in zl.items():
+            ti= repr(k) +"\t" +repr(v)+"\n";
+            te+=ti;
+        wfd8(zl.fn,te);#Exceptions during cleanup are always ignored; see the object.__del__() documentation:
+##    deli=__del__#for
+##class lazy:1
+    ##diMdirs=None
+def ordiMdirs():# Dictionary of Directory
+    global diMdirs
+    diMdirs=globals().get("diMdirs") or dict([j.split("\t")[:2] for j in wfd(os.environ["cpa"]+r"\data\dirs-{}.txt".format(T45)).r(lines=True) if j[:2]])
+    return diMdirs
+#
+def fFlat(li,lirn):
+    if(type(li)==list):
+        for j in li:
+            r1=fFlat(j,lirn)
+##            lirn.extend(r1)
+    else:
+        r1=li
+        lirn.append(r1)
+    return lirn
+class List(list):
+    def rx(zl,te):
+        ir1=re.compile(te)
+        zl.res=[]
+        for i,j in enumerate(zl):
+            mo=ir1.search(j)
+            if mo:
+                zl.res.append(j)
+        return zl.res
+    def rxenu(zl,te):
+        ir1=re.compile(te)
+        zl.res=[]
+        for i,j in enumerate(zl):
+            mo=ir1.search(j)
+            if mo:
+                zl.res.append((i,j))
+        return zl.res
+    def __lt__(zl,o): return zl.append(o)
+    def __lshift__(zl,li): return zl.extend(li)
+    #def __getitem__(zl,k):
+    def getx(zl,k,v):
+        return zl.index(k) if k in zl else v
+    def u(zl,k,v):
+        zl[zl.index(k)]=v
+##    def up(zl,v):
+orList=List
+class ListHash(List):#from collections import OrderedDict
+    def put(zl,k,v):#up
+        a
+class orLiset(set):#unique list
+    pass
+    def cmp(zl,ot):
+        zl.cmp[x](zl[y],ot)
+##        if(role=="cmp"):split(sel)
+    def get(zl,x,y,role="edit"):
+        return zl[y][x]
+class LastOperation(List):
+    def __init__(zl,li=(),threshold=30,wriIni=False,k="",uniq=True):
+        zl.threshold=threshold
+        zl.see=-1
+        zl.uniq=uniq
+        if(wriIni):#dict.setdefault()
+            if(k in wriIni):
+                li=wriIni[k]
+            list.__init__(zl,li)
+            wriIni[k]=zl
+        else:
+            list.__init__(zl,li)
+    def rm(zl,te):
+        if zl.uniq and (te in zl):
+            zl.pop(zl.index(te))
+    def ap(zl,te):
+        if zl.uniq and (te in zl):
+            zl._ap(zl.pop(zl.index(te)))
+        else:
+            if(len(zl)>=zl.threshold):zl.pop()
+            zl._ap(te)
+        zl.see=0
+    def aprx(zl,te):#Word completion
+        if zl.uniq and (zl.get(te)):
+            zl._ap(zl.pop(zl.res[0][0]))
+        else:
+            if(len(zl)>=zl.threshold):zl.pop()
+            zl._ap(te)
+        zl.see=0
+##    def _ap(zl,element):
+##        zl.insert(0,element)
+    _ap=lambda zl,x:zl.insert(0,x)
+    def get(zl,te):
+        r=zl.rxenu(te)
+        return r[0]
+    def up(zl):
+        if(len(zl)-1>zl.see):
+            zl.see+=1
+        return zl[zl.see]
+    def down(zl):
+        if(zl.see>0):
+            zl.see-=1
+            return zl[zl.see]
+clHistry=LastOperation
+##class cycle():
+class orLog(LastOperation):
+    def __call__(zl,*a):
+        if(len(zl)>=zl.threshold):zl.pop(0)
+        zl.append((a[0],a[1:]))
+        return zl
+    def __repr__(zl):
+        if not zl: return "[]"
+        rn=[f[1] for f in zl.find(zl[-1][0])]#findByLastKey
+        return str(rn)
+    def find(zl,pat):
+        ir1=re.compile(str(pat))
+        rn= [f for f in zl if ir1.search(str(f[0]))]
+        return rn
+imorLog=orLog(threshold=4432)
+##logi=lambda *x:imorLog.ap(x[0],x[1:])
+lg=logi=imorLog
+lgf=logifind=lambda x="":imorLog.find(x)
+lgfv=lgf2=lambda x="":[f[1] for f in imorLog.find(x)]# value
+lglf=lambda x:jw(lf,[jw(" ",[str(f) for f in l]) for l in lgfv(x)])
+##jw(lf,[l for l in lgfv(x)])
+lgc=lambda: imorLog.clear()
+def msri(proc,lp):#mashiroInner
+    fil = sys.argv
+    if(len(fil) == 1):
+        pr("please drop off the file");input();exit()
+    for fi in fil[1:]:
+        proc(fi,lp);
+mashiro=msri;
+gif=r"(jpg|jpeg|png|gif|tiff|jfif|webp)$"
+ignoreFiles=(r"R:\TEMP",r"R:\Clip1.txt.txt",r"R:\OnClipChange1.txt",r"R:\Recycled",r'R:\System Volume Information')
+def listdir(r=None,iref="",walk=False,flat=False,isdir=False):
+    "f in listdir() if not(f in ignoreFiles)"
+    assert ifexist(r or "."),r
+    if type(iref)==str:iref=re.compile(iref,re.I).search
+    li=[(jofn(r,f) if flat else f) for f in (os.listdir(r) if not walk else walky(r)) if ((os.path.abspath(jofn(r or "",f)) not in ignoreFiles) and (iref(f)))]
+    if isdir: li=[f for f in li if isdir(jofn(r,f) if r else f)]
+    return li
+def walky(r):
+    for p, ds ,fs in os.walk(r):
+        for fn in ds+fs:
+            yield jofn(p,fn)
+def unfoldfiles(ars,ap=False):
+    for fn in ars:
+        if os.path.isfile(fn):
+            fn
+        else:
+            lifn=walky(fn)
+            for fn in lifn:
+                fn
+def orWalk(d,proc,lp):#CallBackWalk
+    waw = os.walk(ddf[0])
+    for r, ds ,fs in waw:
+        mod=ddf[2].search(r)
+        if mod :#除外子孫のフォルダをさらに(被除外リスト)出力からも除外
+            lidex.append(r);
+        else:
+            ldir=[]
+            for fc in fs:
+                ldir.append(fc)
+            orcb(ldir,r,ddf)
+def rnWalk(d,inc,exc):
+    irInc=[re.compile(f,re.I) for f in inc]
+    irExc=[re.compile(f,re.I) for f in exc]
+    lii=[]
+    for r, ds ,fs in os.walk(d):
+        dsfs=ds+fs
+        for fn in dsfs:
+            for ire in irInc:
+                mod=ire.search(fn)
+                if mod :
+                    lii.append((r,fn));
+                    break
+    for k,(r,fn) in enumerate(lii):
+            for ire in irExc:
+                mod=ire.search(fn)
+                if mod :
+                    lii.pop(k);
+                    break
+    return lii
+def ywalk(dn=None,dr=0,pop=-1):
+    ds=[dn or os.getcwd()]
+    while 1:
+        cd=ds.pop(pop)
+        ag=os.listdir(cd)
+        if dr: ag=ag[::dr]
+        for f in ag: yield cd,ag,jofn(cd,f)
+        else:# not break return
+            ds+=[fp for f in ag if os.path.isdir(fp:=jofn(cd,f))]
+            if not ds : break
+            continue
+        break
+while 0:
+        sn=hhwr(dn=listdir(r"c:\v\t",iref=isdir)[0])
+        dnd=os.path.dirname(sn.dn)
+        if(dnd in [r"c:\v"]): break
+        for cd,fs,fp in ywalk(dnd):
+            pass
+        li=(list(listdir(dnd,iref=isdir)))
+        ix=li.index(os.path.basename(sn.dn))
+##prexit([f for f in ywalk(r"c:\v\t")])
+def nxDir(fn,ceil,fs=0,dr=1):
+    for n in range(9):
+        dn=lfnd(fn)
+        if dn in ceil:
+            return
+        fs=listdir(dn,flat=1)
+        if fn == fs[-dr]:# -1 | 0  # last sister
+            fn=dn
+        else:
+            if not dr: fs.reverse()
+            for nxf in fs[fs.index(fn)+1:]:
+                fn=jofn(dn, fs[fs.index(fn)+1])
+                if os.path.isfile(fn):
+                    yield fn
+                else:
+                    for cd, ag, fnw in ywalk(fn,dr=0 if dr else -1):
+                        yield fnw
+def nxfortst(*a):
+    for n,f in enumerate(nxDir(*a,dr=1)):
+        print(n,f)
+##prexit("nxfor:",nxfortst(r"C:\v\T\eva7\cover\..jpeg",(r"C:\v",)))
+def merge(li,fl="f"):
+    l4=orList()
+    for f1,f2 in li:
+        if not f1.endswith("\\"): f1+="\\"
+        li1=[f[len(f1):] for f in listdir(f1,walk=1)][::-1]
+        for fe in li1:
+            src=jofn(f1,fe)
+            dst=jofn(f2,fe)
+            assert dst.startswith(f2),(f1,f2,fe,dst)
+            inidi(lfnd(dst))
+            if isdir(dst):
+                inidi(dst)
+            else:
+                copy=1
+                if ifexist(dst):
+                    copy=0
+                    if "f" in fl:# force, modi
+                        copy=1
+                    elif "m" in fl and (lfn.getmtime(src)-lfn.getmtime(dst) > 1):
+                        copy=1
+                if copy:
+                    l4<(fe)
+                    shutil.copy2(src, dst)
+    return l4
+#prexit(merge([[r"C:\v\T\lvlv",r"r:\hono"]],"m"))
+def listDrive(ignore="ABD"):
+    return [L for L in (chr(c) for c in range(65,90+1)) if os.path.exists(L+':') and (L)not in ignore]
+def getFolderSize(folder):
+    total_size = 0 #os.path.getsize(folder)#4096
+    for item in os.listdir(folder):
+        itempath = jofn(folder, item)
+        if os.path.isfile(itempath):
+            total_size += os.path.getsize(itempath)
+        elif os.path.isdir(itempath):
+            total_size += getFolderSize(itempath)
+    return total_size
+def lamrec(fp1,fn, fpEnum,F=0,pare=None):
+    fp1(fn,pare,F,0)
+    #print(" "*F, fn)
+    for f2 in fpEnum(fn):
+        lamrec(fp1,f2, fpEnum,F+1,fn)
+    fp1(fn,pare,F,1)
+
+def abSize(size,M="",_1024=1024):# 1234 > 1,234
+    # return f"{size:,}"
+    li=[];mb=""
+    for heavy in "KMGTE":
+        m= size % _1024
+        size= size // _1024
+        li.append(m)
+        if(heavy==M):
+            li=[]
+            mb=M
+        if(size):mb
+        else: break
+    return jw(",",("{:03}".format(f) for f in li[::-1])).lstrip("0")+mb
+##prexit(_:=(1,2026,3,4) ,abSize(sum([1024**n*f for n,f in enumerate(_[::-1])]),"K"))#
+def crbs(li):
+ def binarySearchRec(goal,q0,q1,fpSave):
+    mid = q0+(q1-q0)/2
+    if q0>q1: return
+    size=fpSave(mid)
+    if goal == size:
+       return mid
+    elif goal > size:
+       return binarySearchRec(goal,mid+1,q1,fpSave)
+    else:
+       return binarySearchRec(goal,q0,mid-1,fpSave)
+ return binarySearchRec
+def binarySearch(fpSave,goal,q0,q1,li):
+    while q0<=q1:
+          mid = int(q0+(q1-q0)/2)
+          size=fpSave(mid)
+          li.append((mid,size))
+          if(goal == size):
+             return li#mid
+          elif goal > size:
+             q0 = mid + 1
+          else:
+             q1 = mid - 1
+    if 0:
+          mid = (q0+(q1-q0)/2)
+          size=fpSave(mid)
+          li.append((mid,size))
+    return li
+##print(binarySearch(lambda e:e*100,501,0,20,[]))
+def mvvideo(src,vfl,suffix):#VideoFolder,拡張子
+    ire = re.compile(suffix,re.I)
+    files = os.listdir(src)
+    count=0
+    for f in files:
+        mo= ire.match(f)
+        if(mo):
+            sfi= src+"\\"+f;
+            vfi= vfl+"\\"+f;
+            #print(vfi,sfi)
+            os.rename(sfi,vfi)
+            count+=1;
+    return count;
+def mvdir(src,vfl,suffix):#VideoFolder,拡張子
+    ire = re.compile(suffix,re.I)
+    files = os.walk(src)
+    count=0
+    for r,ds,fs in files:
+        for f in ds:
+            mo= ire.match(f)
+            if(mo):
+                sfi= r+"\\"+f;
+                vfi= vfl+"\\"+f;
+                #print(vfi,sfi)
+                try:
+                    os.rename(sfi,vfi)
+                except a as XP:
+                    pass
+                count+=1;
+    return count;
+def copyTree(src,dist,pat):
+    pass
+def nxnum(WorkDir,fn):#Create sequencial number filename 001~99999
+    'r=nxnum(".","%sx.jpg")'
+    pat=fn%r"(\d{1,3})"
+    ire=re.compile(pat);
+    xmax=0;
+    for n in os.listdir(WorkDir):
+        mo=ire.search(n);
+        if mo:
+            m1=mo.group(1)
+            xi = int(m1)
+            if(xmax < xi):
+                xmax = xi
+    xmax+=1
+    rr = str(xmax).zfill(3);
+    rr=fn%rr;
+    return rr;
+def nxnu2m(WorkDir,fn,nZfill=3):
+    ire=re.compile(re.escape(fn)%r"(\d{1,})");
+    xmax=max([0]+[int(mo.group(1)) for mo in [ire.search(f) for f in os.listdir(WorkDir)] if mo])
+    rr = str(xmax+1).zfill(nZfill);
+    rr=fn%rr;
+    return rr;
+def nxNumFull(WorkDir,fn,nZfill=3):#return FullPath
+    resFn=nxnu2m(WorkDir,fn,nZfill=nZfill)
+    return jofn(WorkDir,resFn)
+def nxNumFullSplit(fn,nZfill=3):#FullPath
+    resFn=nxnu2m(*os.path.split(fn),nZfill=nZfill)
+    return jofn(os.path.split(fn)[0],resFn)
+#
+montail=(0,31,28,31,30,31,30 ,31,31,30,31,30,31)
+import csv
+class oc:#orcsv
+    ordelimiter="\t"
+def wcsw(fn,li):
+    for code in ("cp932","utf-16"):
+        try:
+            with open(fn, 'w',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+            break
+        except UnicodeEncodeError as XP:
+            continue;
+def writecs8(fn,li):
+    return wcsv(fn,li,("cp932","utf-8"))
+def wcsv(fn,li,cs=("utf-8",)):
+    for code in cs:
+        try:
+            with open(fn, 'w',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+            break
+        except UnicodeEncodeError as XP:
+            continue;
+def acsw(fn,li,code="cp932"):
+            with open(fn, 'a',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+def acswvp84n534983v(fn,li):
+    for code in ("cp932","utf-16"):#No good
+        try:
+            with open(fn, 'a',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+            break
+        except UnicodeEncodeError as XP:
+            continue;
+def rcsr(fn):
+    for code in ("utf-8",):#("cp932","utf-8","utf-8"):
+        try:
+            lines =[];
+            with open(fn, 'r',encoding=code, newline='') as fpr:
+                reader = csv.reader(fpr, delimiter=oc.ordelimiter, lineterminator='\n')
+                for line in reader:
+##                    print(line)
+                    lines.append(line);
+            return lines;
+        except UnicodeDecodeError as XP:
+            continue;
+#list(csv.reader(['"-f" 2 9'],delimiter=" "))
+##X/
+def zelp0(lio,fi,irz0=re.compile(r"h/",re.I),irs=0,irx=()):
+    "oList, fn, ir, rnzkList"
+    tel=rfdlv(fi)
+    for k,f in enumerate(tel):
+        mo=irz0.search(f);
+        if mo and not (irx and any(x.search(f) for x in irx)):
+            if(irs):
+                f=rnzk(f,irs)
+            lio.append((k,f))
+    return lio
+def orgrepir(li,fi,ir1):
+    tel=rfdlv(fi)
+    for k,f in enumerate(tel):
+        mo=irz0.search(f);
+        if mo:
+            lio.append((k,f))
+    return lio
+def orgrep(li,fi,pat):
+    ir1=re.compile(pat);
+    li=orgrepir(li,fi,ir1);
+    return lio;
+def orgrepdir(currentdir,pat):
+    filelist=os.listdir(currentdir)
+    matchlist=[orgrep(f) for f in filelist]
+    return matchlist;
+if 1:#time
+#time.strptime("1970,1,1, ","%Y,%m,%d, ")
+#time.mktime(time.strptime("1976,2,29, 9,3,4.56","%Y,%m,%d, %H,%M,%S.%f"))
+#time.gmtime(232.324)
+#time.strftime("%Y")
+#time.time();time.mktime(time.localtime())
+    def timea(ar):#a to day
+        time.mktime((1970,1,1, 9,10,10,  3,1,0))
+        time.mktime((1970,2,31, 25,66,66,  1,1,1))
+        return
+letters='abcdefghijklmnopqrstuvwxyABCDEFGHIJKLMNOPQRSTUVWXY'
+def letter_digit(te,ln=2,zfill=0):
+    a=[]
+##    for c in
+def i2l(d,letters=letters):
+    a=[]
+    while d:
+        d,e=divmod(d,len(letters))
+        a.append(letters[e])
+    return jw("",a[::-1]) or letters[0]
+#
+#graph
+def fncore(fn,exist=False,cc=1,fldn=0):
+    fn=fn.replace("\\","/")
+    fnli=fn.split("/")#.__iter__()
+    for nc,f in enumerate(fnli):
+        if f not in ("Downloads","downfile","freerapid") and (len(f) >= 8 or f.endswith("-") or len(f) != len(f.encode("mbcs"))) and not(f.endswith("@")):
+            if fldn: return jw("/",fnli[:nc+1])
+            fn=jw("/",fnli[nc:])
+            break
+    pat=[("#.*?#",""),(r"[:_/]"," "),(r"\bv?(\d+)[sbw]?[e]?",r"\1"),(r" z(\d+)","")]
+##    pat+=[("\(.*?\)","")]#(1)
+    if not exist: fn=rnzk(fn,pat).strip()
+    if cc==1:fn=fn.lower()
+    if cc==2:pass # camel case
+    return fn
+def fncx(fn): return fncore(fn,True)
+class clfn:
+    def __init__(sl,**kw):
+        sl.__dict__.update(kw)
+    def __call__(sl,fn,dirs=()):
+        for dn in dirs or sl.dirs:
+            if lfn.exists(f2:=jw(lfn,dn,fn)):
+                return f2
+if cpa:
+    pmfolder=(#r"c:\v\jext",
+r"C:\Users\user\Downloads\dval\n2",
+#r"C:\Users\user\Downloads\dval\t1",
+r"C:\Users\user\Downloads\dval\t2",
+r"C:\Users\user\Downloads\dval\t5",
+r"C:\Users\user\Downloads\dval\t9",
+)+tuple(jofn(r"c:\v\zv",f) for f in os.listdir(r"c:\v\zv"))
+    xcore=clfn(dirs=pmfolder)
+#
+def _gettps(fnzv,dncore):
+    fnzv= fnzv or jofn(diMdirs["mtm"],"data","zv.txt")
+    itemdict=eval(wfd(fnzv).r())
+    tps=itemdict.setdefault(dncore,dict())
+    return tps
+def gettps(fnzv,dncore=None):
+    fnzv=jofn(*[fnzv] if fnzv else (diMdirs["mtm"],"data","zv"),dncore)
+    if ifexist(fnzv):
+        tps=puni(eval(wfd(fnzv).r()))
+    else:tps=puni()
+    tps.fn=fnzv
+    return tps
+#
+
+##class hhwrproto(dict):pass
+class hhwrproto(p310, dict):
+    def __init__(zl,*aw,**kw):
+##        super
+        for f in aw: zl.update(f)
+        zl.update(kw)
+        for f,v in kw.items():
+            if v==None: zl.pop(f)
+    def str(zl,order=None, sp=" : ", lf=lf, ls=repr):
+        return jw(lf,(key +sp+ ls(zl[key]) for key in order or zl if key in zl))
+    def __setattr__(zl,at,v):
+        zl[at]=v
+    def __mod__(zl,li):pass
+    def __sub__(zl,li): return zl.__x(li)
+    def __truediv__(zl,l): return zl.__x((l,))
+    def __x(zl,li):#exclude
+        for f in li:
+            zl.pop(f,0)
+        return zl
+    #def copy():
+#class hhwrx(hhwr):
+    def hh(zl,li=None):
+        zl.parser = ArgumentParser()
+        zl.parser.add_argument("fil",nargs="*")#all other
+        if li: zl+li
+        return zl
+    def __add__(zl,li):
+        for f in li:
+            f1,t=f[:2]
+            lenli,default= f[2:] if(len(f)==4) else (None,None)
+            if not isinstance(t,type):
+                lenli=0
+                if isinstance(t, (tuple,list)): lenli=len(t)
+                default=t
+                t=type(t)
+            if t==bool and "store true":                                zl.parser.add_argument(f1,           action="store_true")
+            else:
+                zl.parser.add_argument(f1, type=t, nargs=lenli or None, default=default)
+        return zl
+    def ho(zl,te=None):
+        w=zl.parser.parse_args(te and csv.reader([te.strip()],delimiter=" ").__next__())
+        zl.update(w.__dict__)
+        zl.pop("parser")
+        return zl
+    def __getattr__(zl,at):
+        return zl[at]
+##    def __vars__(zl):wefw
+class hhwr(hhwrproto):
+    def __getattr__(zl,at):
+        return zl.get(at)
+        return None
+hhwrproto().str
+##prexit((hhwr(w=2,f=4) - ("w",)).str())
+##prexit((hhwr(w=2,f=4,ff=4)/"w"/"f").str())
+##w=hhwr();w.f=2;pr(w.f)
+##print(hhwr({"e":1},{"e":4}))
+##print("vars;",vars(w))
+###print(hhwr().hh([("-f",str),("-re",str),("-ns",str)]).ho())
+##print(dict(**hhwr(w=2)), {"ww":2})
+##prexit(hhwr(w=2)==hhwr(w=3), hhwr()==hhwr())
+cls=hhwrproto()
+cls.mp4="mp3|mp4|mkv|flv|ogg|webm"
+#
+def set2(sl,ob,value):
+    for f in value.split(): ob.__dict__[f]=sl.__dict__.get(f)
+import json
+##def pl(fn,tfn="",pl="p"): return jsonload(fn,tfn=tfn,pl=pl)
+def jsonload(fn,tfn="",pl="json"):
+        if pl=="json":
+            fp=(json.loads,json.dumps)
+        elif pl=="p":
+            import pickle
+            fp=(pickle.loads, pickle.dumps)
+        if not tfn:
+            import hashlib
+            te=hashlib.sha256(fn.encode()).hexdigest()
+            tfn=jofn(tfolder,"wft;"+te)
+        if ifexist(tfn):
+            if pl=="json": te=wfd(tfn).r()
+            if pl=="p": te=wfd(tfn).rb()
+            js=fp[0](te or "")
+        else:js={}
+        def log(js=js): wfd(tfn).t(fp[1](js))
+        table=hhwr(t=js,l=len(js),fn=fn,tfn=tfn,log=log)
+        return table, js, tfn, log
+def wfupdate(fn,pat,count):
+        imw=wfd(fn)
+        te=imw.r()
+        if callable(pat):te=pat(te)
+        else: te=rnzk(te,pat)
+        cs=[te.count(f) for f,c in count]
+        assert not any(c!=co for (f,c),co in zip(count,cs)),cs
+        imw.w(te,copy=0)
+        return te
+if 1:
+  def pmobile(*w,**W):
+    pmobilelib=impt((os.environ["AlfiPython"]+"/escape/nagano/e3escapeMtm"));
+    return pmobilelib.pmobile(*w,**W)
+  def note():
+    return impt(os.environ["AlfiPython"]+r"/qt/clas"+"/qNote1")
+    return "note+"
+def xfil(ap,flinput=1):
+    hh=hhwr().hh(ap).ho()
+    if hh.fil:fl= hh.fil
+    elif flinput:
+        fl=input("w copy:")
+        if fl:
+            if fl[0]==";": fl=hh.ho(fl)
+            else:    fl=fl.split()
+        #else:fl=[]
+    return hh,fl
+##def genefp(li):
+##    def fp1(fn,pare,F,after):l
+##    def fpEnum(fn):
+##    lamrec(fp1,li,fpEnum)
+import importlib; from importlib import import_module
+def impt(fn,reload=1,**_):
+    dir,fir=lfn.split(fn)
+    if dir: sys.path.append(dir)
+    cf=cfile(fn)
+    if cf in sys.modules:
+        mod=sys.modules[cf]
+        if reload: importlib.reload(mod)
+    else:
+        mod=import_module(cf)#pass
+    #dimod[cf]=mod
+    if dir: sys.path.pop()
+    return mod
+def zen(wfn):
+    wfn=orsub({":":"：", "<":"(",">":")","\\":"／"},wfn)
+    return wfn
+if __name__ == '__main__':
+    print(os.getcwd());
+    hh={
+        "letter_digit":1,
+##        "afdt":1,
+##        "exception":1, "except1":1,
+##        "ast":1,
+##        "dif3":5,
+    }
+    hw=hhwr(hh)
+    hw.new36=1200
+    if hw.dif3:
+        t1="am,mm,gf,jpefg".split(",")
+        t2="pm,mm,gif,jpg".split(",")
+        prexit(dif3(t1,t2))
+    if 0:
+        t=orbench(pr)
+        orror(str(t),"  ",str(time.clock()),str(time.clock()),str(orbench(pr)))
+        t1 =""
+        pr("line",line())#25LineNunber
+        t2="12346"
+        url=r"http://www.kk.iij4u.or.jp/~k/wave/"
+        ret=cmpd(t2,"12345")
+        prline(ret,t2.find("1",1))
+        unimj="Über Zäune";
+        li=[1,2,3]
+    if(0):
+        eu=esfn(url);
+        wfdt(eu,"lkjl");
+        e2=exfn(eu);
+        pr(bool(url==e2));
+        pr(url,lf,e2,lf,eu);
+    if {"exception","except1"}.issubset(hh):
+        try:
+##            [][0]
+            #exec("2\nrk")
+            (f for f in "").__next__()
+        except Exception as e:
+            e2=traceback.format_exc()
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            e3=traceback.format_exception(exc_type, exc_value,exc_traceback)
+            e4=[ f for f in e3 if re.search(r"Mjmoji",f)]
+            print(rnzk("-- "+jw("\n-- ", e2.splitlines()),[(r"\\","/")]))
+            print(e4,lf,findProgram(e),lf,'File "line')
+    if {"ast"}.issubset(hh):
+        import ast
+        print(ast.dump(ast.parse("if 1:1")))
+        w=ast.parse("sn.l[2]")
+        q=[(f,list(ast.iter_fields(f))) for f in ast.walk(w)]
+        for f,n in q:
+            if n:print(len(n),n)
+##    prexit(emrestore("c"))
+    if hw.new36:# f-string
+        print(f"f-string: {hw.new36:,} str:left,{hh!s:>22}")
+#Operator precedence() ~ / + >> & ^ | in > not and or if
+##npp(r'"C:/cpy/Mjmoji/pr/give it try.pyw" -n2')