# -*- coding: utf-8 -*- robe_version="1;;" ##import sys;import os;sys.path.append(os.environ["cpy"]+r"\Mjmoji");from mw 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 membile={} def membile(fp,membile=membile): membilefp=membile.setdefault(fp,{}) @functools.wraps(fp) def f(*w,**W): if(p:=membilefp.get((w,str(W)))):return p p=fp(*w,**W) membilefp[(w,str(W))]=p return p f.membile=membilefp return f def rint(w): if not typeint(w): assert 0,"not rint" return int(w) 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=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 isinstance(e1, str): e1=e1.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) "contextmanager" ##@contextmanager ##def __pushd(dir): ## try: yield chdir(pop:=dir) ## finally: chdir(pop) def chdirc(fil=0,idx=1):# mv to z droped file if not fil:fil=sys.argv[1:] if isinstance(fil,(hhww)): 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("---") 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): with pushd("."): 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"") 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) _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, timedelta, timezone JST = timezone(timedelta(hours=+9), 'JST') ##def today(): _now=0 def tp(te="%Y%m%d-%H%M%S",n=2, JST=JST ):#%f global _now while 1: ((t:=datetime.now(JST))) now=t.strftime(te) if n:now+="-{}".format(f"{t.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 #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:]) #emove(r"r:\02zv.txt") def fripfn(*w): ff=w[0]+"fripfn" os.rename(w[0],ff) os.rename(w[1],w[0]) os.rename(ff,w[1]) #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.split("\n") 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 colonsplitf(fn): return orsplit2(wfd(fn).r(),"\t:",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*)a"),"1 2a")) ##prexit(findall(re.compile(r"(\d)(?P2)?"),"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 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:\fwfw-search.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-=1 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'"", line (\d+)(), in \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([mdir("wiff"),*w]) def npp(*w): if not w: return mdir("npp") orPOA([mdir("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 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 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: # 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] class _: def __init__(zl,fn,unquote=1): zl.fn=fn zl.unquote=unquote w="" def split(zl): zl.w={f:(v[0]) for f,*v in orsplit(wfd(zl.fn).r(),"\t") if v} def __call__(zl,at): if not zl.w: zl.split() return zl.w[at] def __getattr__(zl,at): return zl(at) if cpa: mdir=_(os.environ["cpa"]+r"\data\dirs-{}.txt".format(T45)) class _(_): def split(zl): from urllib.parse import unquote if not zl.unquote: unquote=fpreturn zl.w={f:unquote(v[-1]) for f,*v in orsplit2(wfd(zl.fn).r(),"\t")} abenatsumi=_(lfn.abspath(__file__+"/../"+"abenatsumi.txt")) # def fFlat(li,lirn): if(type(li)==list): for j in li: L1=fFlat(j,lirn) else: L1=li lirn.append(L1) 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=[(jwdir(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(jwdir(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=hhww(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(mdir("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 (mdir("mtm"),"data","zv"),dncore) if ifexist(fnzv): tps=puni(eval(wfd(fnzv).r())) else:tps=puni() tps.fn=fnzv return tps # ##class hhwwproto(dict):pass class hhwwproto(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(): 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 hhww(hhwwproto): def __getattr__(zl,at): return zl.get(at) return None hhwwproto().str ##prexit((hhww(w=2,f=4) - ("w",)).str()) ##prexit((hhww(w=2,f=4,ff=4)/"w"/"f").str()) ##w=hhww();w.f=2;pr(w.f) ##print(hhww({"e":1},{"e":4})) ##print("vars;",vars(w)) ###print(hhww().hh([("-f",str),("-re",str),("-ns",str)]).ho()) ##print(dict(**hhww(w=2)), {"ww":2}) ##prexit(hhww(w=2)==hhww(w=3), hhww()==hhww()) cls=hhwwproto() 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 jsontext(li):return json.dumps(li) 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 flw==0: if pl=="json": te=wfd(tfn).r() if pl=="p": te=wfd(tfn).rb() js=fp[0](te or "") else:js=hhww() def log(te=js): if fltmp:wfd(tfn).t(fp[1](te)) else: wfd(tfn).w(fp[1](te), copy=0) if flw!=0: log(flw) table=hhww(t=js,l=len(js),fn=fn,tfn=tfn,log=log) return table, js, tfn, log def wfupdate(fn,pat,count,te=""): if fn: 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 if fn: imw.w(te,copy=0) return te if 1: @membile def pmobile(*w,**W): pmobilelib=impt((os.environ["cpy"]+f"/escape/nagano/e3escapeMtm"),reload=0); return pmobilelib.pmobile(*w,**W) def fppmobile(*w,**W): pmobilelib=impt((os.environ["cpy"]+f"/escape/nagano/e3escapeMtm"),reload=0); p=membile(pmobilelib.pmobile)(2,presort=1) return p(*w,**W) def note(): return impt(os.environ["cpy"]+r"/qt/lib"+"/qNote1", reload=0) global_app=iniap() return "note+" def x4(): return impt(cpy+"/Generator/x4orlexi") def xfil(ap,flinput=1): hh=hhww().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 find_spec=getattr(importlib,b'\x75\x74\x69\x6C'.decode()).find_spec module_from_spec=getattr(importlib,b'\x75\x74\x69\x6C'.decode()).module_from_spec importtool=getattr(importlib,b'\x75\x74\x69\x6C'.decode()) def impt1(fn,reload=True, lazy=False, **_): 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)# orText() not found else: mod=import_module(cf)#pass if dir: sys.path.pop() return mod def impt(fn,reload=True, lazy=False, **_): dir,fir=lfn.split(fn) #sys.path.append(os.path.abspath(dir)) cf=cfile(fn) if cf in sys.modules and not reload: mod=sys.modules[cf] #if reload: importlib.reload(mod)# orText() not found else: f9=fn if not dir: for p in [os.getcwd(), *sys.path]: if ifexist(f9:=jwdir(p,fn)): break if ifexist(f9:=(f9+".py")):break if 1: if not ifexist(f9): f9+=".py" assert ifexist(f9), "module not found: "+fn spec=importtool.spec_from_file_location(cf,f9) assert spec, "import from file location;"+f9 #print("spec;",[ spec.name, spec.origin], flush=True) if lazy: spec.loader = LazyLoader(spec.loader) mod = module_from_spec(spec) sys.modules[cf] = mod if "import": getattr(spec.loader, b'\x65\x78\x65\x63_\x6D\x6F\x64\x75\x6C\x65'.decode())(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:,} string: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") if 1: import socket def better_send(feeding, host=(),cb=()): socket_port_web = socket.socket(socket.AF_INET, socket.SOCK_STREAM) socket_port_web.settimeout(1) #socket_port_web.connect(("localhost",5010)) socket_port_web.connect(("127.0.0.1",5010)) # sent = 0 while sent < len(feeding): sent = sent + socket_port_web.send(feeding[sent:]) # while True: long = socket_port_web.recv(4096) if len(long) == 0: # No more data received break #response = response + long; yield long #return response def transfer(feeding, host): tea=b"" for et in better_send(feeding,host): tea+=et return tea if 1: finalcb=cbTry cbstop=finalcb