apple

neo server.py

@@ -70,6 +70,8 @@ def run1(data):
             impt(("c2/"+fn2),reload=fn['reload'])
 @app.post(handle_post)
 def handle_post():
+    header=(dict(req.headers));
+    if header.get("saty")!=(os.environ.get("saty") or saty):return '{"e2":"set header"}'
     try:
         #print(request.get_data())
         if request.is_json and (data:=request.get_json()):
@@ -92,7 +94,7 @@ def handle_post():
 def read_root():
     return {"Hello": "World,"}
 if __name__ == '__main__':
-    hh,fl=hhfl([["-port","5000"]],flinput=0)
+    hh,fl=hhfl([["-port",""],["-host","0.0.0.0"]],flinput=0)
     if face!="face" or hh.port:
         print(hh)
-        app.run(host="0.0.0.0", port=hh.port)
+        app.run(host=hh.host, port=hh.port or 5000)

requirements.txt

@@ -1,3 +1,17 @@
+flask
 requests
 pyngrok
-flask
+cryptography
+psutil
+
+
+flask
+opencv-python
+
+
+torch
+diffusers
+transformers
+accelerate
+ftfy
+xformers

wr.py

@@ -1,1808 +0,0 @@
-# -*- 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
-if "Byte":
-                                                                                    from                io import StringIO, BytesIO
-
-
-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:
-    cpy=os.path.abspath(__file__+"\\..\\..")
-    cpw=os.path.abspath(__file__+"\\..")
-    T45=os.environ["USERNAME"]
-    cpa=os.environ["cpa"]
-    ZVCherryPicker=cpy+"\\qt\\ZVCherryPicker.pyw"
-    HeartNote=cpy+"\\qt\\HeartNote.pyw"
-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)
-        return 1
-    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 printline(*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, mtime(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=mtime(zl.fn)
-            zl.sha=hashlib.sha256(te.encode()).digest()
-        return te
-    def csvr(zl,*aw,lf=None,tab=None,**kw):
-        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 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()
-##            zl.LastError=e
-            open(r"r:\fail reason.txt","w").write(str(e))
-            open(r"r:\fail "+tp()+".txt", "wb").write(e1)
-            #with open(nxNumFull(r"r:","%s"+os.path.split(fn)[1],nZfill=2), 'wb') as fo:
-            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
-    parser = ArgumentParser(description="command_error")
-    parser.add_argument("-f",type=str)
-    parser.add_argument("-re",type=str)
-    parser.add_argument("fil",nargs="*")
-    arps=parser.parse_args(a)
-    return arps
-def a2a(li):
-    return jw(" ",('"{}"'.format(f) for f in li))
-def chdir(x=0):
-    os.chdir(lfnd(sys.argv[x]))
-class pushd:
-    def __init__(sl,dir):
-        if 1: inidi(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):
-    "/foo.mkv, f2 >> /f2foo.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)
-#
-if "jwdir":
-    def lgest(lis):
-        l=lis[0]
-        for l2 in lis:
-            if l2>l: l=l2
-        return l
-    def notanybad(lis):
-        for f in lis:
-            if not f: return False
-        return True
-    #from jwdir import *
-    jwdir=getattr(os.path,b'\x6A\x6F\x69\x6E'.decode())
-    jofn=jwdir
-    def jw(te,list):
-        assert isinstance(te,(str,bytes))
-        #assert 1==len(typ:=set(type(f) for f in [te,*list])), ["type not unique ",typ]
-        assert hasattr(list,"__iter__")
-        return getattr(te,b'\x6A\x6F\x69\x6E'.decode())(list)
-    lfjw=functools.partial(jw, lf)
-    _lfn="LibFileName"#="lfn"
-    lfn=os.path
-    lfnd=lfn.dirname
-    lfndir=lfn.dirname
-    lfnb=lfn.basename
-    mtime=lfn.getmtime
-    ctime=lfn.getctime
-    n12=__builtins__[b'\x65\x6E\x75\x6D\x65\x72\x61\x74\x65'.decode()]
-    def fpn1(lis):
-        if isinstance(lis,(dict)): return getattr(lis,b'\x69\x74\x65\x6D\x73'.decode())()
-        return n12(lis)
-    sleep=getattr(time,b'\x73\x6C\x65\x65\x70'.decode())
-    def shuttown(stdin,*w):
-        assert hasattr(stdin, b'\x63\x6C\x6F\x73\x65'.decode())
-        return getattr(stdin,b'\x63\x6C\x6F\x73\x65'.decode())(*w)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-def dq(te):#double quote
-    if(te[0] != '"' or te[-1] != '"'):
-        return '"'+te+'"';
-def prit(*w):
-    te=jw(" ", [str(f) for f in w])+lf;
-##    print("exit-%d "%inspect.currentframe().f_back.f_lineno, end="");
-    print("exit-")
-    print(te, end="");
-    if w[:1]==(1,):input("*")
-    sys.exit();
-prexit=prit
-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 isdir(fn):
-    if os.path.isdir(fn): return fn;
-    if os.path.isfile(fn): return 0;
-    if os.path.islink(fn): return 0;
-
-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 lfn.exists(fn)
-def AbImage1(fs,grouping=False):#連番を表示しない。冗長になるのを防ぐ
-    lioView=[]
-    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;
-
-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
-_perf_counter0=time.perf_counter()
-def perf_counter():
-    return time.perf_counter()-_perf_counter0
-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=jofn(fn[0]+":/", "emove______")
-    else:emo=fn
-    li=rcsr(jofn(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 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 colonsplit(te): return orsplit2(te,":",strip= str.strip)
-##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));
-##    pr(pat);
-    irfinal=re.compile(pat)
-    def f6(mo):
-        mg= mo.group(0);#[0];
-        if (mg in map0):
-            mg=map0[mg];
-        else:
-            assert 0,("orsub");
-        return mg;
-    t2=irfinal.sub(f6,te);
-    return t2;
-def orsubne(map0,te):#NonEscape
-    pat=jw("|",map0);
-##    pr(pat);
-    irfinal=re.compile(pat)
-##    mapi={orsub({r"\[":"[",r"\]":"]",r"^":"","$":""},k):v for k,v in map0.items()}
-    def f6(mo):
-        mg= mo.group(0);#[0];
-        li=[v for k,v in map0.items() if re.match(k,mg)]
-        if li:pass
-        else:
-            assert 0,("orsub")
-        return mg;
-    t2=irfinal.sub(f6,te);
-    return t2;
-#
-def findall(ire,te,rebuild=0):
-    ire=re.compile(*ire) if not isinstance(ire,re.Pattern) else ire
-    ran=(0,0)#range
-    while 1:
-        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
-    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()
-def difri(T,splitlines=fpreturn):
-    import difflib as dif
-    return (dif.SequenceMatcher(None,*[splitlines(t) for t in T]))
-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
-
-#---------
-def rnz(te,li,opt=re.S|re.I):
-    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,**ww):
-    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
-def traverse(reg,te,bug=False,**ww):
-    fn=reg; #fn.teli=[te]
-    def fp1(fn,pare,F,after):
-      if after:return
-      fn.teli=[]
-      for ta in pare.teli if pare else [te]:
-        rin,rx1,rx2=fn.pat
-        li=compilex(rin).findall(ta)
-        for t1 in li:
-            for rex in rx1:
-                if rex.search(t1):continue
-            fn.teli.append(t1)
-      from mlwebOrWeb import webrap
-##      print(fn, f"{fn.flget=}")
-      if fn.flget: #fn.teli=[ webrap().gtoff(f,"utf-8") for f in fn.teli]
-        li=[]
-        for n1,f in enumerate(fn.teli):
-            print(f"download {n1+1} / {len(fn.teli)}")
-            li.append(webrap().gtoff(f,"utf-8"))
-        fn.teli=li
-    def mimi(fn):return fn.mimi
-    lamrec(fp1,fn, mimi,F=0,pare=None)
-    return
-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
-import th
-cbTryLock=th.Lock()
-def cbTry(f,ercb=None,lo=0,ww=(),pr=0):
-##    flq=1 if hasattr(f, "__self__") and isinstance(f.__self__, orq) else 0
-##    la=lambda e: a[1:]
-    counter=0
-    @functools.wraps(f)
-    def cb(*a,**k):
-        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: except2(0,find="p",edit="npp")
-        except Exception as e: # exit is not exception
-        #except:
-            et=0
-            cb.counter+=1
-            if cb.counter>10:return
-            if ercb: et=cbTry(ercb)(e)
-            if et:return
-            if pr: print(except2(0,find=""))
-            else:
-##                with cbTryLock:#?
-                    except2(0,find="p",edit="note")
-##            e2=except2()
-##            Mini(te)
-    cb.counter=0
-    return cb
-
-def edipt(te="",find="p",edit=0,fntbl=()):
-    if edit:return edipt_edit(te,find,edit,fntbl)
-    e2=te or traceback.format_exc()
-    e2=e2.replace("Traceback (most recent call last):","-"*9)
-    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=[[fppmobile(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 (fppmobile(omiterror(e2)),mo)
-        if find=="node":
-            mo=compiled(r'at ([\w\.]* )?\(?(C:.*?):(\d+):(\d+)').findall(e2)
-            mo=[[fppmobile(f) for f in f2] for f2 in mo if not any(((compilex(r"/python|\\Python\\|importlib").search(f2[0])), ("//pass" in f2[-1]) )) ]
-            mo=[[w[f] for f in (1,2,0,3)] for w in mo]
-            return (fppmobile(omiterror(e2)),mo)
-        if 0:
-            mo=re.findall(r'"<string>", line (\d+)(), in <module>\n(.*)',e2)
-            return mo
-    return fppmobile(omiterror(e2))
-except2=edipt
-def edipt_edit(te,find,edit=0,fntbl=()):
-    e2=edipt(te,find=find)
-    t1=e2[0].splitlines().pop()
-    if "dialog rejected;" in t1: return
-    if "SystemExit" in t1: return
-    from qNote1 import  iniap, Mini, clhk
-    from dialog_ import orDialog
-    app=iniap()
-    mono=orDialog()
-    if not e2[1]: return Mini(e2)
-    if find=="p":
-        mo=[clhk(f, teh=(f"({cfile(f[0])}), {f[1]}, {f[2]}, \n{f[3]}")) for f in e2[1]]
-    if find=="node":
-        mo=[clhk(f, teh=(f"({cfile(f[0])}), {f[1]}, {f[2]}")) for f in e2[1]]
-    if (mf:=re.search("AssertionError: (.*)", e2[0])): mo=[clhk("*", teh=mf.group(1))]+mo
-    whw=[mo+[e2[0]]]
-    mono.xch(whw)
-    if not mono.fiFiles:return
-    fn,*_=mono.pickupli()
-    if type(fn)==str:return e2
-    (fn,pos,mod,te)=fn
-    if fn in fntbl: fn=fntbl[fn]
-    print(fn,fntbl)
-    #npp(fn,f"-n{pos}")
-    orPOA([HeartNote, fn, "-pos",pos,"0"])
-    return e2
-def omiterror(e2):
-    return rnz(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=rnz(te,(
-##                (r"'(mpv property does not exist)',.*?b('.*?'),",r"\1 \2"),
-##                (r"\d+",""),
-##                ))
-def orpopen(mp3):
-    import subprocess as p
-    return p.Popen([mp3],shell=True);
-def orPOA(cmd,shell=True):
-    import subprocess as p
-    return p.Popen(cmd,shell=shell);
-def popen1(cmd,shell=True):
-    import subprocess as p
-    return p.Popen(cmd,shell=shell).wait()
-##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)
-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 updateIncliment(zl,k):
-        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 sortedlist(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,f,te):
-        #{f,[[open,],[file,],[copy,],]};findcopy():lipop(f,"copy")
-        return zl.lipop(f,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,te=""):#配列の長さは同じにする
-        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]
-            assert isinstance(z2,puni), "not list len"#,f
-            if te:
-                assert f[-1] not in z2, "not list len. 123 12"#,f
-                z2[f[-1]]=te
-            else:
-                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)
-class pini(puni):
-    def __init__(zl,d={},fn="pini00.ini"):
-        dict.__init__(zl,d);
-        zl.fn=lfn.abspath(fn);
-        if lfn.isfile(fn):
-            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="";
-        #print(os.getcwd())
-        for f,v in fpn1(zl):
-            ti= repr(f) +"\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 mdir(f): return ordiMdirs()[f]
-#
-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,f): return zl.append(f)
-    def __lshift__(zl,li): return zl.extend(li)
-    #def __getitem__(zl,f):
-    def getx(zl,f,v):
-        return zl.index(f) if f in zl else v
-    def u(zl,f,v):
-        zl[zl.index(f)]=v
-##    def up(zl,v):
-orList=List
-class ListHash(List):#from collections import OrderedDict
-    def put(zl,k,v):#up
-        1
-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,*w):
-        if(len(zl)>=zl.threshold):zl.pop(0)
-        zl.append((w[0],w[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=32100)
-##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(src):
-                inidi(dst)
-            else:
-                copy=1
-                if ifexist(dst):
-                    copy=0
-                    if "f" in fl:# force, modi
-                        copy=1
-                    elif "m" in fl and (mtime(src)-mtime(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, List"
-    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=rnz(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(te):
-        time.mktime((1970,1,1, 9,10,10,  3,1,0))
-        time.mktime((1970,2,31, 25,66,66,  1,1,1))
-        return
-    def hourmin(te): return te.replace("hour","H").replace("min","M").replace("second","S")
-letters='abcdefghijklmnopqrstuvwxyABCDEFGHIJKLMNOPQRSTUVWXY'
-def letter_digit(te,ln=2,zfill=0):
-    for c in te:1
-def i2l(d,letters=letters):
-    li2=[]
-    while d:
-        d,e=divmod(d,len(letters))
-        li2.append(letters[e])
-    return jw("",li2[::-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=rnz(fn,pat).strip()
-    if cc==1:fn=fn.lower()
-    if cc==2:pass # camel case
-    return fn
-def fncx(fn): return fncore(fn,True)
-def findzv(fn):
-    dir,fn=lfn.split(fn)
-    if not dir:dir=os.getcwd()
-    for f in range(9):
-        #zl+[dir,fn]
-        with pushd(dir):
-            if ifexist(fn): return lfn.abspath(fn).replace("\\","/")
-            if not lfnb(dir): return
-            dir,_=lfn.split(dir)
-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:=(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")# need vn pickle
-        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 typejson(te):
-##    try: json.loads(te)
-def jsonload(fn,tfn="",pl="json",flw=0,fltmp=1):
-        if pl=="json":
-            fp=(json.loads,json.dumps)
-        elif pl=="p":
-            import pickle
-            fp=(pickle.loads, pickle.dumps)
-        else:fp=()
-        if not tfn:
-            import hashlib
-            te=hashlib.sha256(fn.encode()).hexdigest()
-            tfn=jofn(tfolder,"wft;"+te)
-        tfn=lfn.abspath(tfn)
-        #print(tfn)
-        if ifexist(tfn) and not flw:
-            if pl=="json": te=wfd(tfn).r()
-            if pl=="p": te=wfd(tfn).rb()
-            js=fp[0](te or "")
-        else:js={}
-        def log(te=js):
-            if fltmp:wfd(tfn).t(fp[1](te))
-            else: wfd(tfn).w(fp[1](te), copy=0)
-        if flw: log(flw)
-        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=rnz(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"]+f"/escape/nagano/e3escapeMtm"),reload=0);
-    return pmobilelib.pmobile(*w,**W)
-  def fppmobile(*w,**W):
-    pmobilelib=impt((os.environ["AlfiPython"]+f"/escape/nagano/e3escapeMtm"),reload=0);
-    return pmobilelib.fppmobile(*w,**W)
-  def note():
-    return impt(os.environ["AlfiPython"]+r"/qt/lib"+"/qNote1", reload=0)
-    global_app=iniap()
-    return "note+"
-  def x4():
-    return impt(cpy+"/Generator/x4orlexi")
-def xfil(ap,flinput=1):
-    hh=hhwr().hh(ap).ho()
-    fl=hh.fil
-    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
-hhfl=xfil
-##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)
-    sys.path.append(os.path.abspath(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
-def newthan(tfn,fn): return mtime(tfn)>mtime(fn)
-def memof(fp):
-    fp._memof={}
-    @functools.wraps(fp)
-    def p(zl,*w):
-        #print(fp._memof, w)
-        if(mf:=fp._memof.get(w)): return mf
-        else:
-            pm=fp(zl,*w)
-            fp._memof[w]=pm
-            return pm
-    return p
-if __name__ == '__main__':
-    print(os.getcwd());
-    hh={
-##        "ast":1,
-##        "dif3":5,
-    }
-    hw,fl=xfil([])
-    hw.new36=1200
-    if "dif3" in hw:
-        t1="am,mm,gf,jpefg".split(",")
-        t2="pm,mm,gif,jpg".split(",")
-        prexit(dif3(t1,t2))
-    if(0):
-        eu=esfn(url);
-        wfdt(eu,"lkjl");
-        e2=exfn(eu);
-        pr(bool(url==e2));
-        pr(url,lf,e2,lf,eu);
-    if "ast" in fl:
-        import ast
-        @cbTry
-        def pcompile(te):1
-        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')
-#compilev(r"(?<=1).*?(?=\n)").sub("2","1\nfw\n")