apple

altEdit.py

@@ -1,267 +0,0 @@
-# -*- coding: utf-8 -*-
-##import sys;sys.path.append("N:\\afilen\\program\\python\\Mjmoji");from wr import *
-import sys
-import time
-from ctypes import *
-import subprocess as p
-from wr import *
-
-def scroll(*ww):
-    import edit_
-#
-#
-
-
-def ctockai( text ):
-        import os
-        logfile=[fr"{tfolder}/1.txt",fr"{tfolder}/2er.txt"]
-##        for f in logfile: os.path.exists(f) and os.remove(f)
-        ip = p.Popen( ['cmd'], stdin=p.PIPE, shell=True )
-        #text="%s > %s 2>&1 \n"%(text,erfile)#write
-        text="{} 1> {} 2> {} \n".format(text,*logfile)#write
-##        orror(text);
-        ip.stdin.write( text.encode("cp932"))
-        shuttown(ip.stdin)
-        retcode = ip.wait()
-        #
-        lir=list(open(f,"rb").read() for f in logfile)
-##        lir=[te.replace(b"\r\r\n",b"\n").replace(b"\r\n",b"\n").decode("mbcs") for te in lir]
-        lir=[te.replace(b"\r\r\n",b"\n").replace(b"\r\n",b"\n").decode("utf8") for te in lir]
-        return (retcode,lir[0],lir[1])
-def ctod( text ,sh=True,cp="cp932",si=None):
-        ip = p.Popen( ['cmd']if(sh)else text, stdin=p.PIPE, stdout=p.PIPE,stderr=p.PIPE,shell=sh )
-        if 0:#no
-            ip.stdin.write("echo 1\n".encode())
-            for x in iter(ip.stdout.readline, b''):x
-        if 0:#no
-            ip.stdin.write("chcp 65001\n".encode("cp932"))
-            ip.stdin.flush()
-            ip.stdout.flush()
-            print(ip.stdout.read());
-        if(sh):
-            text+="\n";
-            ip.stdin.write( text.encode("cp932"))
-            shuttown(ip.stdin)
-        elif(si):
-            ip.stdin.write(si)
-            shuttown(ip.stdin)
-
-        retcode=None
-        try:
-##            retcode = ip.wait(timeout=0)
-            retcode = ip.wait()
-            res=(ip.stdout.read()[96:],
-                ip.stderr.read())
-##            for f in range(212): er=ip.stdout.read(2)
-        except p.TimeoutExpired as e:
-##            return ip.stdout.readline(21)
-            res=(ip.stdout.read()[96:],
-                ip.stderr.read())
-            fds
-##        cp="utf8"
-##        try:
-##            return retcode,r.decode(cp),er.decode(cp),ip
-##        except:
-##            cp="cp932"
-##            return retcode,r.decode(cp),er.decode(cp),ip
-        res=[te.replace(b"\r\r\n",b"\n").replace(b"\r\n",b"\n") for te in res]
-        from wr import vcs
-        res=[vcs(te) for te in res]
-        return retcode,*res,ip
-def Runw(li): ctod(li,sh=False)
-##(ctockai(jw(" ",["node",r"C:\v\P\electron\electron-quick-start\or1.js"])))
-##print(ctockai("dir ."))
-##print(ctod(jw(" ",["node",r"C:\v\P\electron\electron-quick-start\or1.js"])))
-import os
-import th
-class cltof():
- def __init__(zl):
-    #zl.mutex=fwe
-    zl.ev=th.Event()
-    zl.lock=th.Lock()
-    os.environ['PYTHONIOENCODING'] =  'utf-8'
- def ctof(zl,cb,to, text ,null=""):
-    from wr import vcs, tp, wfd
-    zl.ev.clear()
-    if 0==to:to=3600*12
-    time0=time.perf_counter()
-    def fppc():
-        return time.perf_counter()-time0
-    def fpin(cb,text):
-        date=tp()
-        if isinstance(text,(list,tuple)): c=os.path.basename((text[0]))
-        elif isinstance(text,(str)):  c= "C"
-        logfile=zl.logfile=[fr"{tfolder}/ctof_{c}_{x}_{date}.txt" for x in ("1","2")]
-##        print(text,cb)
-        for f in logfile: os.path.exists(f) and os.remove(f)
-##        ip = p.Popen( [("echo ff"),"1>",logfile[0],"2>",logfile[1]], shell=True )
-        if isinstance(text,(list,tuple)): te= [*text,"1>",logfile[0],"2>",logfile[1]]
-        elif isinstance(text,(str)):te= text+" 1> {} 2> {}".format(*logfile)
-        if not null or 1:
-            zl.ip=ip=p.Popen(text,shell=True, stdout=open(logfile[0],"w"), stderr=open(logfile[1],"w"), stdin=p.PIPE)
-            #
-        while any([False==os.path.exists(f) for f in logfile]):
-            print("not ready;",[os.path.exists(f) for f in logfile],te)
-            sleep(0.1)
-        while 1:
-##            try:
-                #with open(logfile[0],"rb") as fo:
-                lifo=[open(f,"rb") for f in logfile]
-                while 1:
-                    poll=zl.poll=ip.poll()
-                    for x,fo in enumerate(lifo):
-                        bit=fo.read()
-##                        print("p;",poll,bit)#lwt
-                        if bit and cb: cb(x+1, vcs(bit))
-                    if poll!=None: break
-                    sleep(0.2)
-                    if poll!=None: break
-                    if to<(d:=fppc()):return
-##                    print(d)
-##            except 2:                f
-                if ip.poll()!=None:break
-                if to<(d:=fppc()):break
-    def fpin1(*w):
-        cb,*_=w
-        try:
-            res=fpin(*w)
-##        except Exception as e:
-##            wfd("r:\\logEdit.txt").t(str(e))
-        finally:
-            zl.ev.set()
-        return res
-    t=th.run(fpin1,(cb,text))
-    return t
- @property
- def te(zl):
-    from wr import vcs
-    if 1:
-        logfile=zl.logfile
-        lir=list(open(f,"rb").read() for f in logfile)
-##        lir=[te.replace(b"\r\r\n",b"\n").replace(b"\r\n",b"\n").decode("mbcs") for te in lir]
-##        print(lir[0].decode("cp932"),poll)
-        lir=[vcs(te.replace(b"\r\r\n",b"\n").replace(b"\r\n",b"\n"))for te in lir]
-        return (zl.poll,lir[0],lir[1])
- @property
- def wa(zl):
-    try:zl.ev.wait()
-    except KeyboardInterrupt as e:e
-    return zl
- @staticmethod
- def cbpr(std,b): print(f"{std} cblen({len(b)})  {b}")
- def put(p,te):
-    p.ip.stdin.write(te.encode())
-    p.ip.stdin.flush()
-def ctof(*w):
-    p=cltof()
-    p.ctof(*w)
-    return p
-##def watofin(*w):
-##    p=ctof(*w).wa
-##    return p
-##def returnwat():
-def watof(*w):
-    p=ctof(*w)
-    te=p.wa.te
-    return te[1]+"\n"+te[2]
-def tofu(*w):
-    return ctof(*w).wa.te
-import subprocess, shlex
-from threading import Timer
-
-def run(cmd, timeout_sec):
-  proc = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE,
-    stderr=subprocess.PIPE)
-  kill_proc = lambda p: p.kill()
-  timer = Timer(timeout_sec, kill_proc, [proc])
-  try:
-    timer.start()
-    stdout,stderr = proc.communicate()
-  finally:
-    timer.cancel()
-#
-import time
-import signal,os
-def reloadFull(timeout=2.2, me=[sys.argv[0],"-r"]):
-        ip=p.Popen(me,shell=True)
-        try:
-            ri=ip.wait(timeout=timeout)#idea
-            print("eof. continue")
-        except subprocess.TimeoutExpired as e:
-            print("reload",e)
-            sys.exit(0)
-def r1reloadFull(dure,me):
-    def handler(signum, frame):
-        print("reload,handler",signum)
-    def handlerth(signum, frame):
-        print("reload",signum)
-##        sys.exit(0)#no
-        os.kill(os.getpid(),signal.SIGINT)
-##        os.kill(os.getpid(),signal.SIGTERM)#ideaLk
-    signal.signal(signal.SIGTERM, handler)
-    signal.signal(signal.SIGINT, handler)
-    timer=Timer(dure-0.2,handlerth,args=[1,2])
-    #
-    try:
-        timer.start()
-        ip=p.Popen( me,bufsize=2, stdin=p.PIPE, stdout=p.PIPE,stderr=p.PIPE,shell=True )
-        while ip.poll() is None:
-            sleep(0.2)
-            print("while_poll",ip.poll())
-            pass
-##            print(ip.stdout.read())
-        print("poll2",ip.poll())
-        try:
-##            ri=ip.wait(timeout=dure)#idea
-            ri=ip.wait()
-        except subprocess.TimeoutExpired as e:
-            print(e)
-##            sys.exit(0)
-##        ri
-    finally:
-        timer.cancel()
-
-if __name__ == '__main__':
-    import edit_
-    acs()
-    fil=sys.argv
-    c1=fil[1]if(len(fil)>=2)else None
-    def reheasal():
-        import multiprocessing as mlti
-        sys.stdin.conn
-
-    if(c1=="-out"):
-        for j in fil[2]:
-            sleep(0.3)
-            sys.stdout.write(j)
-    if(c1=="-c"):
-        for f in ":苍天\n:":
-            print(f)
-##            sys.stdout.write(f)
-    if(c1=="-e"): fwf
-    if(c1=="-lf"):
-        for f in "123\n234":
-            print(f)
-            print(" start ",end="")
-##            input("pw")
-            sys.stdout.flush()
-            print("", flush=True)#,file=stdout
-            sleep(1)
-    if not c1:
-        print("c1;")
-##    reloadFull([r"dir"])
-##    reloadFull(2,[r"N:\afilen\program\python\work\ClipArg.py"] + args)
-##    r1reloadFull(5,[r"N:\afilen\program\python\qt\ClipProcess2.pyw"] + args)
-##        r1reloadFull(5,[fil[0],"-out", jw(".",[str(j)for j in list(range(2))])] )
-##        ctof(__file__,"-out","21212")
-##        print(";;",ctof(f'{__file__} -out 21\n\n\n'))
-        #? print(";;",ctof(f'{__file__}',"-out", '"21\n21"'))
-##        print(";;",ctof(f'{__file__}',"-out", "21"))
-#lwt
-        def cb(std,b): print(f"{std} cblen({len(b)})  {b}")
-##        print(";",ctof(cb,'ffmpeg',"-y","-i",r"r:\\p9.mkv","r:\\fw.mp4"))
-##        print(";;",ctof(f'{__file__}',"-c",''))
-##        print(";;",ctof(f'{__file__}',"-e"))
-##        print(";;",watof(cb,10,(f'{__file__}',"-lf")))
-        print(";;",watof(cb,10,(f'{__file__}'+" -lf")))
-##        print(";;",watof(f'{__file__}',"-out",'21212苍天\nf'))#?

mlwebOrWeb.py

@@ -0,0 +1,549 @@
+
+# -*- coding: utf-8 -*-
+# MarkUp Language
+import zipOrZip as oz
+import mw; from mw import *
+import re,os
+import urllib.request
+from urllib.parse import urlparse,quote,quote_plus,unquote,unquote_plus,urlencode
+
+orror=mw.orro3("roml.txt");
+urltmpdir="r:\\TEMP\\"
+hp="https://"
+class webrap:
+    user_agents = [
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36',
+##        'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.129 Mobile Safari/537.36'
+        'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11',
+        'Opera/9.25 (Windows NT 5.1; U; en)',
+        'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)',
+        'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)',
+        'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12'
+        'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9'
+    ]
+    headers=[]
+    headers.append( ('User-agent', user_agents[0]))
+    headers.append((b'\x41\x63\x63\x65\x70\x74-\x65\x6E\x63\x6F\x64\x69\x6E\x67'.decode(), 'gzip'))# encoding
+    def __init__(zl):
+        zl.user_agent=webrap.user_agents[0];
+        zl.code="utf-8";
+    def gZip(zl):
+        byte = zl.httpres.read()
+        hs={f.lower():v for f,v in zl.httpres.getheaders()}
+        if('content-encoding' in hs and hs['content-encoding'] == 'gzip'):
+            byte = oz.extgz(byte);
+        return byte
+    def g0(zl):
+        opener = urllib.request.build_opener() #
+        opener.addheaders = zl.headers
+        #print(zl.url)
+        zl.httpres = opener.open(zl.url)#,timeout=2)
+        return zl.gZip();
+    def getCache(zl):#offline cache
+        esurl=zl.url
+        esurl=mw.esfn(esurl.replace(hp,""))
+#        esurl=unquote_plus(esurl,zl.code)
+        zl.offfile=urltmpdir+esurl
+##        zl.offfile=zl.offfile[:255]
+        if(zl.url.find("://")==-1):
+            zl.url=hp+zl.url
+        if(mw.ifexist(zl.offfile)):
+            byte=mw.rfdb(zl.offfile)
+            zl.byte=byte;
+            return zl.byte
+        return None;
+    def orwgetof0(zl):
+        if(not zl.getCache()):
+##            zl.url=quote_plus(zl.url,encoding=code,safe=":/")
+            zl.byte = zl.g0();
+            wfdb(zl.offfile,zl.byte); orRemove(zl.offfile, rembat="wget cache remove.bat")
+        return zl.byte;
+    def orwgetoff(url,post=0):
+        zl=webrap()
+        zl.url=url;
+        return zl.orwgetof0()
+    def utf(zl,url):
+        zl.url=url;
+        t1=zl.orwgetof0();
+        t2=t1.decode(zl.code);
+        return t2;
+    def gton(zl,*aw): return zl.gtoff(*aw,on=True)
+    def gtoff(zl,url,code="",on=False):
+        if "#" in url: url=url.split("#")[0]
+        zl.url=quote(unquote_plus(url),safe=":/?=")
+##        print(zl.url)
+        zl.code=code;
+        t1=zl.g0() if on else zl.orwgetof0();
+        if code==bytes: return t1
+        t2=t1.decode(code) if code else vcs(t1);
+        return t2;
+    def wget(zl,*aw):return zl.gtoff(*aw,on=False)
+    #
+    def orwget(zl,url,post=0,off=1):#legacy
+        esurl=url
+        esurl=esfn(esurl.replace(hp,""))
+        esurl=unquote_plus(esurl,encoding=zl.code)
+        zl.offfile=urltmpdir+esurl
+        if(url.find(hp)==-1):
+            url=hp+url
+        if(ifexist(zl.offfile) and off):
+            byte=rfdb(zl.offfile)
+        else:
+##            url=quote_plus(url,encoding=code,safe=":/")
+            user_agent=webrap.user_agents[0];
+            opener = urllib.request.build_opener()
+            opener.addheaders = [ ('User-agent', user_agent),  ('Accept-encoding', 'gzip')]
+            qpost=zl.mkpost(post) if post else None#
+            zl.res = opener.open(url,qpost.encode("utf8"))#zl.res
+            byte = zl.res.read()
+            hs={k:v for k,v in zl.res.getheaders()}
+            if('Content-Encoding' in hs and hs['Content-Encoding'] == 'gzip'):
+                byte = oz.extgz(byte);
+            if off: wfdb(zl.offfile,byte)
+        return byte.decode(zl.code);
+    def mkpost(zl,q):
+        return jw("&",[jw("=",[quote_plus(str(w),encoding=zl.code) for w in f]) for f in q])
+##        return tea
+##        l = []
+        if 1:
+            tea=""
+            for k, v in q:
+                k = quote_plus(str(k),encoding=zl.code)
+                v = quote_plus(str(v),encoding=zl.code)
+                #l.append(k + '=' + v)
+                tea+=k+"="+v+"&"
+            return tea[:-1]
+    irle=re.compile(r'<a href="(?P<href>.+?)".*?>(?P<te>.*?)</a>');
+    def le(te):
+        "link extracter"
+        zl.links=webrap.irle.findall(te);
+        return zl.links;
+    def nx(zl,reg,te,url,page=1):
+        "pager"
+        #par=urlparse(zl.url)#netloc path query
+        irnx=re.compile(reg)
+        def fpnxurl(tefp):
+            if not(mo:=irnx.search(tefp)):print("not match regnx"); return
+            else:
+                if type(page)!=int:
+                    nxquery=mo.group(1)
+                    nxquery=nxquery.replace("&amp;","&")
+                    nxurl=jw("------",url, nxquery)
+                    print(nxquery)
+##                    print((zl.url, nxquery), nxurl)
+                    return nxurl
+                return True
+        nxurl=url
+        if te:
+            yield te
+            if type(page)==int: page+=1
+            nxurl=fpnxurl(te)
+        for n in range(page or 0,987987987):
+            if page: nxurl=url.format(n)
+##            print(nxurl)
+            te=zl.gtoff(nxurl,zl.code, on=1)
+            yield te
+            if not(nxurl:=fpnxurl(te)): break
+    def firefox(zl,url):
+        import webbrowser
+        webbrowser.open(url)
+    def ggle(zl,q):
+        zl.code="utf-8"
+        zl.code="shift-jis"
+        post=(("q",q),("hl","ja"))#japan
+        qp=zl.mkpost(post)
+        q2="http://www.google.co.jp/search?"+qp
+        te=zl.orwget(q2)
+        return te
+    def chr(sl,te):lwt
+    ##    文字参照や実体参照を通常の文字に戻す ［Python, Tips］ - Programming Magic5
+    # 実体参照 & 文字参照を通常の文字に戻す
+    @staticmethod
+    def htmlentity2unicode(text):
+        import html.entities  as htmlentitydefs
+        # 正規表現のコンパイル
+        reference_regex = re.compile('&(#x?[0-9a-f]+|[a-z]+);', re.IGNORECASE)
+        num16_regex = re.compile('#x\d+', re.IGNORECASE)
+        num10_regex = re.compile('#\d+', re.IGNORECASE)
+
+        result = ""
+        i = 0
+        while True:
+            # 実体参照 or 文字参照を見つける
+            match = reference_regex.search(text, i)
+            if match is None:
+                result += text[i:]
+                break
+
+            result += text[i:match.start()]
+            i = match.end()
+            name = match.group(1)
+
+            # 実体参照
+            if name in htmlentitydefs.name2codepoint.keys():
+                result += chr(htmlentitydefs.name2codepoint[name])
+            # 文字参照
+            elif num16_regex.match(name):
+                # 16進数
+                result += chr(int('0'+name[1:], 16))
+            elif num10_regex.match(name):
+                # 10進数
+                result += chr(int(name[1:]))
+
+        return result
+
+if 0:
+    webrap().ggle("かんこれ");
+    def yaho(zl,q):
+        zl.code="utf-8"
+        post=(("ei","UTF-8"),("p",q),("n","40"))#nPageNum10|15|20|30|40|100
+        qp=zl.mkpost(post)
+        q2="http://search.yahoo.co.jp/search?"+qp
+        te=zl.orwget(q2)
+        return te
+    def bing(zl,url):
+        esurl=url
+        esurl=esfn(esurl.replace(hp,""))
+        zl.code=code="utf-8"
+        esurl=unquote_plus(esurl,encoding=code)
+        zl.offfile=urltmpdir+esurl
+        if(url.find(hp)==-1):
+            url=hp+url
+        if(ifexist(zl.offfile)):
+            byte=rfdb(zl.offfile)
+        else:
+            #url=quote_plus(url,encoding=code,safe=":/")
+            user_agent=webrap.user_agents[0];
+            opener = urllib.request.build_opener()
+##            opener.addheaders = [ ('','')]
+            opener.addheaders= [('Host',' www.bing.com')]
+            opener.addheaders= [('User-Agent',' Mozilla/5.0 (Windows NT 5.1; rv:26.0) Gecko/20100101 Firefox/26.0')]
+            opener.addheaders= [('Accept',' text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8')]
+            opener.addheaders= [('Accept-Language',' ja,en-us;q=0.7,en;q=0.3')]
+            opener.addheaders= [('Accept-Encoding',' gzip, deflate')]
+            qpost=zl.mkpost(post) if post else None#
+            zl.res = opener.open(url)#zl.res
+            byte = zl.res.read()
+            hs={k:v for k,v in zl.res.getheaders()}#header had raised TypeError
+            if('Content-Encoding' in hs and hs['Content-Encoding'] == 'gzip'):
+                byte = oz.extgz(byte);
+            wfdb(zl.offfile,byte)
+        return byte.decode(code);
+def quotesafe(zl,url):
+    qurl=quote_plus(url,encoding=code,safe=":/&?")
+    write8(r"r:\url1",url)
+    write8(r"r:\url2",qurl)
+if 0:#getoff
+    im=webrap()
+    im.url=r"http://blog.livedoor.jp/yuriss/"
+    te=im.orwgetoff(im.url)
+    wfdb(r"r:\get.txt",te);
+#ftp
+from ftplib import FTP
+class owf:
+    def login(sl,url,aka,pwd):
+        sl.imf=FTP(url)
+        sl.imf.login(aka,pwd)
+    def list(sl):
+        return sl.imf.retrlines("LIST")
+    def cbO(sl,blockData):
+        sl.res+=blockData#packet
+    def o(sl,fn):
+        sl.res=b""
+        ri=sl.imf.retrbinary('RETR '+fn,sl.cbO)
+        return sl.res
+    def uf(sl,fn):
+        with open(fn, "rb")as fo:
+            #_ftp.cwd("/target_dir/")
+            return sl.imf.storbinary("STOR "+os.path.split(fn)[1], fo)
+    def u(sl,fn,fo):#file object
+            return sl.imf.storbinary("STOR "+fn, fo)
+    def dele(sl):
+        sl.imf.quit()
+#------------
+##from __future__ import print_function
+from threading import Thread,Lock,Event,Condition
+import socket
+from contextlib import closing
+import select
+defaultPort=4000
+class orListen(Thread):
+    #python listen
+    def __init__(sl,cb=None,fil=(),ercb=(),**kw):
+        super().__init__(**kw)
+        sl.owari=False
+        if cb: sl._cb=cb
+        sl.fil=fil
+        sl.ercb=ercb or (sl._ercb, [])
+        #
+        sl.port = defaultPort
+    def i4l(sl,port,cb=None,fil=(),ercb=(),**kw):
+        super().__init__(**kw)
+        sl.owari=False
+        assert  sl._cb, "reimmpriment cb"
+        sl.fil=fil
+        sl.ercb=(sl._ercb, [])
+        #
+        sl.host = '127.0.0.1'
+        sl.port = port
+        return sl
+    def main(sl):#, port = defaultPort):
+      backlog = 10
+      bufsize = 4096
+
+      server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+      sl.server_sock=server_sock
+      Set = set([server_sock])
+      try:
+        server_sock.bind((sl.host, sl.port))
+        server_sock.listen(backlog)
+
+        while True:
+          rready, wready, xready = select.select(Set, [], [],5.0)
+##          print("ready")
+          if sl.owari:
+            print("owari select")
+            break
+          for sock in rready:
+            try:
+                if sock is server_sock:
+                  conn, address = server_sock.accept()
+                  Set.add(conn)#peer
+                else:
+                  te = sock.recv(bufsize)
+                  if len(te) == 0:pass
+                  elif te==b"owari":
+                    sock.send(b"len-0;")
+                    Set.remove(sock)
+                    sl.owari=1
+                    shuttown(sock)
+                  else:
+                    sl.sock=sock
+                    sl._cb(te, sl.fil)
+            except Exception as e:
+                except2(edit=1)
+                Set.remove(sock)
+                shuttown(sock)
+                #sl.ercb[0](e,sl.ercb[1])
+      except Exception as e:
+        print(e)
+        except2(edit=1)
+        #sl.ercb[0](e,sl.ercb[1])
+      finally:
+        for sock in Set:
+          shuttown(sock)
+      return
+    def run(sl):#start
+        sl.main()
+##        except ConnectionResetError as er:
+
+    def chkbind(sl):
+      server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+      Set = set([server_sock])
+      try:
+        server_sock.bind((sl.host, sl.port))
+##        server_sock.listen(backlog)
+      except Exception as e:
+        e2=traceback.format_exc()
+        rn=0
+      else:
+        rn=1
+      finally:
+        for sock in Set:
+          shuttown(sock)
+      return rn
+    def Release(sl):#finalist
+        if sl.chkbind(): return
+        send1("127.0.0.1", port=sl.port, te="owari")#4 unblock select
+        sl.owari=True
+class _orListen(orListen):
+    def _cb(sl,te,fil):
+        te=te.decode()
+        print(te)
+        if(te=="x"): sl.Release()
+        #sl.sock.send(te.encode())
+        sl.cb2(te,fil)
+##    _cb=cb
+    def cb2(sl,te,fil):
+        pn=sl.sock.getpeername()
+##        print(te)
+        so=sl.sock
+        if 2:#local
+            lcl=dict(locals())
+            lcl.update({"r":"r:"})
+            try:
+                exec(te,globals(),lcl)
+            except Exception as e:
+                print("exec:", traceback.format_exc())
+            for i in dict(locals()): lcl.pop(i,55)
+            #sl.sock.lcl=lcl
+        #
+        sl.sock.send(lcl["r"].encode())
+    def _ercb(sl,erte,fil):
+        print("---",erte)
+def chkbind(port):
+    return _orListen().i4l(port).chkbind()
+def send1(host, port, te):
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    with closing(sock):
+        sock.connect((host, port))
+        sock.send(te.encode("utf8"))
+def mainClient(fil=(0,),sp=(),iLi=(),host = '127.0.0.1',port = defaultPort,bufsize = 4096,timeout=2.0):
+  let=[]
+  once,=fil
+
+  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+  with closing(sock):
+    sock.connect((host, port))
+    if iLi:
+        for te in iLi:
+            try:
+              sock.send(te.encode('utf-8'))
+              sock.settimeout(timeout)
+              #let.append(sock.recv(bufsize))
+              if 1:
+                for x1 in range(99):
+                    te=sock.recv(bufsize)
+                    if(te):let.append(te)
+              #print(let)
+            except Exception as e:
+                e2=traceback.format_exc()
+                print(e2)
+        return let
+    if once:
+        for n in range(once):
+          try:
+              sock.send(str(n).encode('utf-8'))
+              print(" clientz:",sock.recv(bufsize))
+          except Exception as e:
+            e2=traceback.format_exc()
+            print(e2)
+    while not once:
+      line = sys.stdin.readline().rstrip()
+      if len(line) == 0:
+        print("send x to quit.")
+        break
+      sock.send(line.encode('utf-8'))
+      print(" client:",sock.recv(bufsize))
+  return
+send=mainClient
+if __name__ == '__main__':
+    from subprocess import *
+    import time
+    import sys
+    import traceback
+    hh,fl=hhfl([])
+    hh=hhww()
+##    hh.getaddrinfo=1
+    #
+    if hh.getaddrinfo:
+        print(socket.getaddrinfo("localhost",4000))
+        print(socket.getaddrinfo("localhost",8080))
+    #
+##    post=[3:4,5:6]
+    post=[(1,1),(2,2),(3,3),("q","検索")]
+    q=urlencode(post)
+    print(q)
+    im=webrap()
+    im.code="cp932"
+##    print(im.mkpost(post))
+    if 0:#?
+        rn=webrap().yaho("そのだうみ")
+##        print(rn)
+        rn=webrap.orwgetoff("http://search.yahoo.co.jp/search?")
+        rn=webrap().bing("http://www.bing.com/search?q=かんこれ&qs=n&form=QBLH&filt=all&pq=かんこれ&sc=8-4&sp=-1&sk=")#404repair by delete quote process
+        rn=webrap.orwgetoff("http://livedoor-search.naver.jp/search?c=ld_blog_sb&o_st=livedoor&sm=ldb_top&q=かよちん&search_btn=検索")
+        webrap().bing(r"http://livedoor-search.naver.jp/search?c=ld_blog_sb&o_st=livedoor&sm=ldb_top&q=かよちん&search_btn=検索");
+    if {"ftp"}.issubset(hh):
+        imf=owf()
+        # imf.login("ftp:shinuno.comxa.com","a6091821","heikou2zero")#exc
+        imf.login("red.ribbon.to","shinuno","forget")#exc
+        if {"ftp","ftp1"}.issubset(hh):
+            #all stdout
+            li=imf.list()
+            print("----",li)
+            li=imf.imf.retrlines("NLST")
+            print("----",li)
+            li=imf.imf.retrlines("MLSD")
+            print("----",li)
+        def mkBody(te):
+            t2="""<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+    <html>
+     <head>
+      <title>Index of /video</title>
+     </head>
+     <body>
+     %s
+    </body></html>
+    """%(te)
+            return t2
+        if {"ftp","ftp2"}.issubset(hh):
+            imf.imf.cwd("/public_html/video")
+            print(imf.imf.pwd())
+            print(imf.imf.nlst())
+            #sendcmd("LIST")
+            #
+            from io import BytesIO
+            import time
+            t=time.localtime();
+            t2=("d_dd_d"%(t.tm_mday,t.tm_hour,t.tm_min,t.tm_sec))
+            fn="|"+t2+".txt"
+            fnh="|"+t2+".htm"
+            #no fn932=fn.encode("cp932")
+            ri=imf.u(fn,BytesIO(b"fwfwf"))
+            ri
+            ri=imf.u(fnh,BytesIO(mkBody(time.strftime("%Y_%m/%d %H%M %A %B %c")).encode("utf8")))
+        if {"ftp","ftp3"}.issubset(hh):
+            imf.imf.cwd("/public_html/cgi")
+            #
+            fn=r"N:\afilen\program\html\award\cgi\Dirr1.php"
+            fn=r"N:\afilen\program\html\award\cgi\wget.php"
+            ri=imf.uf(fn)
+    ##        dn=r"N:\afilen\program\html\award\cgi"
+    ##        for fn in os.listdir(dn):imf.uf(jofn(dn,fn))
+    ##    tes2()
+    ##    tes1()
+        imf.dele()
+        import jk987
+    #
+    iml=_orListen()
+    if "client"==arps.f:#?
+      try:
+##        q8erw
+        mainClient([2])
+      except ConnectionRefusedError as er:
+        print(" connectEr: ", str(er))
+      except Exception as e:
+        e2=traceback.format_exc()
+        print(e2)
+      input("owari\n")
+    elif "listen" in hh:
+        iml.start()
+##        Popen(["E:\Python34\python.exe",sys.argv[0]]+["-f","client"],shell=True)
+##        Popen(["start","E:\Python34\python.exe "+jw(" ",[sys.argv[0],"-f","client"])],shell=True)
+##        Popen(["start",r"E:\Python34\python.exe",r"N:\afilen\program\python\qt\ClipProcess2.pyw"],shell=True)#ok
+##        Popen(["start",r"N:\afilen\program\python\qt\ClipProcess2.pyw"],shell=True)#ok
+        for _ in range(4):
+            Popen(["start",sys.argv[0], "-f","client"],shell=True)
+        for f in range(2):
+            print("listen:",f)
+            time.sleep(2.0)
+        iml.owari=True
+    if "clien2"==arps.f:#
+      try:
+        mainClient([None])
+      except Exception as e:
+        e2=traceback.format_exc()
+        print(e2)
+      input("owari\n")
+    elif "ser2" in hh:
+        for i in range(2):
+            Popen(["start",sys.argv[0], "-f","clien2"],shell=True)
+        iml.main()
+        for i in range(2):
+            print("listen:",i)
+            time.sleep(2.0)
+        iml.owari=True
+        #sys.exit()
+#

wr.py → mw.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 robe_version="1;;"
-##import sys;import os;sys.path.append(os.environ["cpy"]+r"\Mjmoji");from wr import * ;
+##import sys;import os;sys.path.append(os.environ["cpy"]+r"\Mjmoji");from mw import * ;
 ##import mlwebOrWeb as ml
 ## wardrobe
 
@@ -33,6 +33,10 @@ else:
 
 class p310:# require version
     def __getstate__(zl):return #pickle
+def rint(w):
+    if not typeint(w):
+        assert 0,"not rint"
+    return int(w)
 def typeint(w):
     try:
         int(w)
@@ -335,7 +339,7 @@ class pushd:
         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 isinstance(fil,(hhww)): fil=fil.fil
     if not fil:
         pr("please drop off the file");input("chdirc()");
     else:
@@ -439,8 +443,7 @@ def dq(te):#double quote
         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("---")
     print(te, end="");
     if w[:1]==(1,):input("*")
     sys.exit();
@@ -553,12 +556,14 @@ 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
+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):#%f
+def tp(te="%Y%m%d-%H%M%S",n=2, JST=JST ):#%f
     global _now
     while 1:
-        ((t:=datetime.now()))
+        ((t:=datetime.now(JST)))
         now=t.strftime(te)
         if n:now+="-{}".format(f"{t.microsecond:06}"[:n])
         if _now!=now:break
@@ -782,7 +787,7 @@ def sas(reg,te,bug=False,**ww):
             #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))
+        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]
@@ -956,10 +961,10 @@ def popen1(cmd,shell=True):
     return p.Popen(cmd,shell=shell).wait()
 ##orPOA(r'start cmd /c "r:\c f.bat"')
 def wiff(w):
-    orPOA([ordiMdirs()["wiff"],*w])
+    orPOA([mdir("wiff"),*w])
 def npp(*w):
-    if not w: return ordiMdirs()["npp"]
-    orPOA([ordiMdirs()["npp"],*w])
+    if not w: return mdir("npp")
+    orPOA([mdir("npp"),*w])
 def nppw(lis,fn=tfolder+"/log"):
     wfd(fn).t(lis)
     npp(fn)
@@ -1282,7 +1287,7 @@ def ywalk(dn=None,dr=0,pop=-1):
             continue
         break
 while 0:
-        sn=hhwr(dn=listdir(r"c:\v\t",iref=isdir)[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):
@@ -1602,12 +1607,12 @@ r"C:\Users\user\Downloads\dval\t9",
     xcore=clfn(dirs=pmfolder)
 #
 def _gettps(fnzv,dncore):
-    fnzv= fnzv or jofn(diMdirs["mtm"],"data","zv.txt")
+    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 (diMdirs["mtm"],"data","zv"),dncore)
+    fnzv=jofn(*[fnzv] if fnzv else (mdir("mtm"),"data","zv"),dncore)
     if ifexist(fnzv):
         tps=puni(eval(wfd(fnzv).r()))
     else:tps=puni()
@@ -1615,8 +1620,8 @@ def gettps(fnzv,dncore=None):
     return tps
 #
 
-##class hhwrproto(dict):pass
-class hhwrproto(p310, dict):
+##class hhwwproto(dict):pass
+class hhwwproto(p310, dict):
     def __init__(zl,*aw,**kw):
 ##        super
         for f in aw: zl.update(f)
@@ -1635,7 +1640,6 @@ class hhwrproto(p310, dict):
             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
@@ -1662,20 +1666,20 @@ class hhwrproto(p310, dict):
     def __getattr__(zl,at):
         return zl[at]
 ##    def __vars__(zl):wefw
-class hhwr(hhwrproto):
+class hhww(hhwwproto):
     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}))
+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(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()
+###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):
@@ -1701,12 +1705,12 @@ def jsonload(fn,tfn="",pl="json",flw=0,fltmp=1):
             if pl=="json": te=wfd(tfn).r()
             if pl=="p": te=wfd(tfn).rb()
             js=fp[0](te or "")
-        else:js={}
+        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: log(flw)
-        table=hhwr(t=js,l=len(js),fn=fn,tfn=tfn,log=log)
+        table=hhww(t=js,l=len(js),fn=fn,tfn=tfn,log=log)
         return table, js, tfn, log
 def wfupdate(fn,pat,count):
         imw=wfd(fn)
@@ -1731,7 +1735,7 @@ if 1:
   def x4():
     return impt(cpy+"/Generator/x4orlexi")
 def xfil(ap,flinput=1):
-    hh=hhwr().hh(ap).ho()
+    hh=hhww().hh(ap).ho()
     fl=hh.fil
     if hh.fil:fl= hh.fil
     elif flinput:
@@ -1776,9 +1780,10 @@ def impt(fn,reload=True, lazy=False, **_):
                 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
-            assert ifexist(f9), (cf,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

neo server.py

@@ -1,4 +1,5 @@
 
+
 # -*- coding: utf-8 -*-
 ##!kill -9 "$(pgrep ngrok)"
 import sys; import os; cpa=os.environ.get("cpa")
@@ -12,7 +13,9 @@ if not os.path.isdir(f:="c2"): repo_clone("https://huggingface.co/spaces/compile
 #
 face="1000"
 ##face="face"
-if os.environ.get("SPACE_HOST"): face="face"
+if os.environ.get("SPACE_HOST"):
+    face="face"
+    saty=os.environ.get("saty")
 if face=="face":1
 elif not cpa:
 ##  from google.colab import drive
@@ -24,8 +27,8 @@ elif not cpa:
   os.environ["tmp"]="/tmp"; os.makedirs("/tmp",exist_ok=True)
 else:
     import sys;import os;sys.path.append(os.environ["cpy"]+r"\Mjmoji");
-##from wr import wfd, inidi, impt, time
-from wr import *
+##from mw import wfd, inidi, impt, time
+from mw import *
 
 
 import flask as flas
@@ -39,7 +42,7 @@ disablelog()
 
 import json
 app = Flask(__name__)
-app.mimi=hhwr()
+app.mimi=hhww()
 app.t0=time.perf_counter()
 handle_post="/handle_post"
 if face=="face":
@@ -53,12 +56,13 @@ elif not cpa:
     port=5000
     conf.get_default().monitor_thread = False
     try:
-        public_url = ngrok.connect(port).public_url
+        p = ngrok.connect(port).public_url
     except:
         ngrok.kill()
         sys.exit()
-    print("tunnel \"{}\" -> \"http://127.0.0.1:{}\"".format(public_url, port))
-    app.config["BASE_URL"] = public_url
+    print("tunnel \"{}\" -> \"://127.0.0.1:{}\"".format(p, port))
+    apl({"fp":"up2", "dir":"w", "fn":"f", "te":json.dumps({"dres":p, "date":repr(time.time())})})
+    app.config["BASE_URL"] = p
 #
 
 def pr2(*w): print(*w)
@@ -79,7 +83,8 @@ def run1(data):
 @app.post(handle_post)
 def handle_post():
     header=(dict(request.headers));
-    if header.get("Saty")!=(os.environ.get("saty") or saty):return '{"e2":"set header"}'
+    if not saty: '{"e2":"set pass"}'
+    if header.get("Saty")!=saty:return '{"e2":"set header"}'
     try:
         #print(request.get_data())
         if request.is_json and (data:=request.get_json()):

tofu_edit.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
-##import sys;sys.path.append("N:\\afilen\\program\\python\\Mjmoji");from wr import *
+##import sys;sys.path.append("N:\\afilen\\program\\python\\Mjmoji");from mw import *
 import sys
 import time
 from ctypes import *
 import subprocess as p
-from wr import *
+from mw import *
 
 def scroll(*ww):
     import edit_
@@ -65,7 +65,7 @@ def ctod( text ,sh=True,cp="cp932",si=None):
 ##            cp="cp932"
 ##            return retcode,r.decode(cp),er.decode(cp),ip
         res=[te.replace(b"\r\r\n",b"\n").replace(b"\r\n",b"\n") for te in res]
-        from wr import vcs
+        from mw import vcs
         res=[vcs(te) for te in res]
         return retcode,*res,ip
 def Runw(li): ctod(li,sh=False)
@@ -81,7 +81,7 @@ class cltof():
     zl.lock=th.Lock()
     os.environ['PYTHONIOENCODING'] =  'utf-8'
  def ctof(zl,cb,to, text ,null=""):
-    from wr import vcs, tp, wfd
+    from mw import vcs, tp, wfd
     zl.ev.clear()
     if 0==to:to=3600*12
     time0=time.perf_counter()
@@ -134,7 +134,7 @@ class cltof():
     return t
  @property
  def te(zl):
-    from wr import vcs
+    from mw import vcs
     if 1:
         logfile=zl.logfile
         lir=list(open(f,"rb").read() for f in logfile)
@@ -152,6 +152,11 @@ class cltof():
  def put(p,te):
     p.ip.stdin.write(te.encode())
     p.ip.stdin.flush()
+
+
+
+
+
 def ctof(*w):
     p=cltof()
     p.ctof(*w)

zipOrZip.py

@@ -0,0 +1,386 @@
+# -*- coding: utf-8 -*-
+##import zipOrZip as zo;
+import gzip, bz2,  tarfile, zipfile, datetime, io
+from io import BytesIO
+import os
+#
+import mw;
+from tofu_edit import ctod
+#
+def extgz(te):
+    buf = BytesIO( te)
+    f = gzip.GzipFile(fileobj=buf)
+    data = f.read()
+    return data;
+def wbgz(te):#writeBuffer
+    buf = BytesIO()
+    f = gzip.GzipFile(fileobj=buf,mode="wb")
+    f.write(te);
+    f.close()#neccesery
+    return buf.getvalue();
+def wfgz(fn,te):#writeFile
+    f = gzip.open(fn,"wb")
+    data = f.write(te)
+    f.close()#同じ名前のファイルがあるとRenameと同じ挙動に
+def wfbz(fn,te):#writeFile
+    f = bz2.BZ2File(fn,"wb")
+    data = f.write(te)
+    f.close()
+def writebzb(te):#writeFilebz Buffer
+    buf = BytesIO()
+    f = bz2.BZ2File(fileobj=buf,mode="wb")#fileobj not work
+    data = f.write(te)
+    f.close()
+    return buf.getvalue()
+def tarlist(fn):
+    with tf.open(fn,"r") as ta:
+        return tf.list()
+def tarprint(fn):
+##    with tarfile.open(fn,"r") as ta:
+##        print(ta.list())
+    ta=tarfile.open(fn,"r")
+    print(ta.list())
+    for tarinfo in ta:
+        print(tarinfo.name,tarinfo.size,  ##          datetime.fromtimestamp(tarinfo.mtime),
+          tarinfo.mtime, oct(tarinfo.mode),            tarinfo.uname, tarinfo.gname)
+    ta.close()
+def tfread(tfn,fn):
+    with tarfile.open(tfn,"r") as ta:
+        ti = ta.getmember(fn)
+        f = ta.extractfile(ti)
+        te= f.read()
+    return te ;
+def writeExtract(dist,fns=()):
+    if(type(fns)==str):
+        with tarfile.open(fns) as ta:
+            ta.extractall(dist)
+def writexz(fn,li3,mode='w|xz'):codetar(li3=li3,mode=mode,fn=fn);
+def codetar(li3,mode='w|',bio=BytesIO(),fn=""):
+    with tarfile.open(name=fn, mode=mode, fileobj=(bio if not fn else None))as ta:
+        for src,dist in li3:
+            ta.add(src,dist)
+    return bio
+def zipread(zfn,fn="",pwd=None):
+    with zipfile.ZipFile(zfn,"r") as zfo:
+        if not fn:return zfo.infolist()
+        #fo=zfo.open(fn,"r",pwd=pwd)
+        data=zfo.read(fn,pwd=pwd)
+        return data
+def zipwrites_full(zfn,li,compress=zipfile.ZIP_DEFLATED, pwd=None):
+    #passward not supported
+    with zipfile.ZipFile(zfn,"w",compression=compress) as zfo:
+        for rfn,wfn in li:
+            zfo.write(rfn,wfn)
+        return zfo.infolist()
+def zipwrites(zfn,li,compress=zipfile.ZIP_DEFLATED, pwd=None):
+    zipwrites_full(zfn,[(fn,fn) for fn in li],compress=compress, pwd=pwd)
+def zipwrites_dir(zfn,dirn,*aw,**kw):
+    import itertools
+    imw=(itertools.chain.from_iterable(([jofn(r,fn) for fn in (ds+fs)] for r, ds, fs in os.walk(dirn) )   ))
+##    dire=kah.split("\\")[-1]
+    li=[(i,i[len(dirn):]) for i in imw]
+    zipwrites_full(zfn,li,*aw,**kw)
+#zipwrites_dir(r"r:\isshonisino.zip",r"r:\temp",compress=zipfile.ZIP_STORED)
+def zipbufi(li):
+    buf = BytesIO()
+    with zipfile.ZipFile(buf,mode="w") as fo:
+        for p,te in li:
+            fo.writestr(p,te);
+##            if type(te)==str: fo.writestr(p,te);
+##            else: fo.write(p,te)
+    #print(buf.getvalue())
+    return buf;
+def zipbuf():
+    #buf=zipbufi([(r"v/w.txt","vw"),("new folder/",""),(r"ほのか","weffw")])
+    buf=zipbufi([(r"nf/nf/0.txt","vw"),("cmczip.com.url",""),(r"nf/nf/cmczip.com.url","")])
+    #buf=BytesIO(buflk)
+    inf=zipread(buf)
+    wr.wfdb(r"c:\v\t\ziptst.zip",buf.getbuffer())
+    print(inf)
+#zipbuf()
+def ziplvlv():
+    b1 = BytesIO()
+    zipwrites_dir(b1,r"c:\v\t\lvlv")
+    buf=zipbufi([(r"v1.zip",b1.getbuffer()),("v2.zip",b1.getbuffer())])
+    zfn=r"c:\v\t\ziptst.zip"
+    wr.wfdb(zfn,buf.getbuffer())
+    print(zipread(zfn))
+##ziplvlv()
+
+#https://www.rarlab.com/rar_add.htm
+os.environ["UNRAR_LIB_PATH"]=r"C:\dll\unrar64.dll"
+try:
+    from unrar import rarfile
+except:0
+def ur(fn):
+        ro=rarfile.RarFile(fn)
+        #ro.comment
+##    print(ro.namelist())
+##    ro.printdir()
+        fs=ro.infolist()
+        for fo in fs[:4]+fs[-2:]:
+            print(fo.filename)
+            ro.extract(fo,dstfolder)
+#for fn in (r"C:\v\jd\Nagato Yuki Shoushitsu v0%d.rar"%d for d in range(6,10)): #exc
+from mw import rfdb, jofn, lfnb
+class zo:
+    def ini1(self,zfn,tmpfolder=""):
+        self.zfn=zfn
+        self.tdn=tdn=jofn(tmpfolder,lfnb(zfn[0]))
+        if not os.path.exists(tdn):
+            os.makedirs(tdn)
+        else: return self
+        if 1:
+            self.tfread=self.tfread
+            for f in zfn: writeExtract(tdn,f)#4 bcmodified
+        else:
+            self.tfread=self.tfread
+        return self
+    def fpfn(self,fn): return jofn(self.tdn, fn)
+    def tfread(self,zfn,fn):
+        return rfdb(jofn(self.tdn, fn))
+##    def __iter__(self):
+##        for f in tempfolder
+    def __enter__(self):
+        return 1
+    def __exit__(self, _type, value, traceback):
+        self.tdn
+    def rmtmp(self):
+        import shutil
+        from datetime import datetime, date, timedelta
+        import time
+        ctime=os.path.getctime(self.tdn)
+        ctime=datetime.fromtimestamp(ctime)
+        flnew=datetime.now()-timedelta(hours=2) < ctime
+        print("remove;",ctime, self.tdn, f"{flnew=}")
+        if flnew: shutil.rmtree(self.tdn)
+
+
+#
+import random
+import string
+import uuid
+import hashlib
+#hashlib.sha1(b"kanata").hexdigest()
+def mkOneTime():return mkPas(uuid.uuid4())
+def mk1p():return print(mkPas(uuid.uuid4(),l=12,letters="d!?-_#"))#keyboard friendly pass
+def mkPas(k,l=24,letters="ad"):
+    diLe={"a":string.ascii_letters, "d": string.digits,   "p":string.punctuation}
+    diLe.update([(p,p)for p in string.punctuation])
+    letters=jw("",[diLe[c]for c in letters])
+    print(letters)
+    #
+    random.seed(k)
+    return (jw('',[random.choice(letters) for i in range(l)]))
+def mkKey(k,l=1234,l2=1):#initial vector, rn key len, range*256
+    random.seed(k)
+    rn=[random.randrange(0,l2*0x100) for i in range(l)]
+    return rn
+def visunel(k,te):
+    t2=[(v+k[i%len(k)])%6 for i,v in enumerate(te)]
+    return t2
+def visuner(k,te):
+    t2=[(v+256-k[i%len(k)])%6 for i,v in enumerate(te)]
+    return t2
+def visunex(k,te):return bytearray([(v^k[i%len(k)]) for i,v in enumerate(te)])#xor
+import array
+import struct
+#http://docs.python.jp/3/library/struct.html
+def pwdlen(pwd):
+    if(type(pwd)==int):
+        a
+def imagineL(pwd,data,fn):
+    datas=[bytes(v)for v in [fn,pwd,data]]
+    lens=[len(i)for i in datas];#(len(pwd),len(data),len(fn),)
+    ba=bytearray(4*len(lens)+ sum(lens))
+##    p1=struct.pack("III"+jw("",[(str(i)+"s")for i in lens]), *lens)
+    p1=struct.pack("III"+jw("",[(str(i)+"s")for i in lens]), *lens+datas)
+    #struct.pack_into("2s",ba,0,b"j")
+##    return p1
+##def imagineL(pwd,data,fn):
+    datas=[fn,pwd,data]
+    lens=struct.unpack("III", p1[:12])
+    p2r=struct.unpack("III"+jw("",[(str(i)+"s")for i in lens]), p1)
+    print(p2r)
+    return p2r
+def main():
+    hh=wr.hhww(mojibake=0)
+    z="gz";
+    fn="fn."+z;
+    te=wr.rfdb(wr.sys.argv[0]);
+    tfn=r"N:\dpDict\naist-jdic-0.4.3.tar.gz"
+    tfn2=["unimj.txt","orror00.txt"]
+    import os
+    import re
+    if 0:
+        wr.inidir("testfldr\\")
+        tarprint(tfn)
+        ta=tarfile.open("testfldr\\ふぁいる.tar.gz","w:gz")
+        for n in tfn2 : ta.add(n)
+        ta.close()
+        print(tfread(tfn,"naist-jdic-0.4.3/README").decode("cp932"))
+    if 0:
+        wfgz(fn,te);
+        wfbz("fあみn.txt.bz2",te);#文字化け
+##        wfbz(str("あいう.txt.bz2".encode("mbcs")),te);
+        bf=wbgz(te);
+        wr.wfdb("f2.txt.gz",bf);
+        pass
+    if 0:#NoWork
+        bf=writebzb(te);
+    def tes2():
+        randkey=mkKey("key",22,1)
+        print(randkey)
+        randkey=mkKey("key2",22,1)
+        print(randkey)
+        coded=visunel(randkey, "amiあみ".encode("utf8"))
+        raw=visuner(randkey,coded)
+        print(coded,bytes(coded),raw, bytes(raw).decode())
+        print("xor",visunex(randkey, visunex(randkey, "amiあみ".encode("utf8"))))
+        #
+        imagineL(randkey,coded,b"ami.c")
+        #
+        mk1p();print(mkOneTime())
+##    class ca(io.m):
+    class ca(io.BufferedIOBase):
+##    class ca(io.BytesIO):
+        def __init__(sl,ar):
+            sl.ar=ar
+            sl.p=0
+        def read(sl,ln):
+##            ri=io.BytesIO.read(sl,ln)
+##            return ri
+            ro=sl.ar[sl.p:sl.p+ln]
+            sl.p=sl.p+ln
+            return bytes(ro)
+        def write(sl,te):
+            sl.ar.extend(list(te))
+##            ri=io.BufferedWriter.write(sl,te)
+##            return ri
+        def getvalue(sl):
+            return bytes(sl.ar)
+    def j1():#no
+        return
+        buf=ca([])
+        with gzip.GzipFile(fileobj=buf,mode="wb") as go:
+            go.write(b"fwefwe")
+        wd=buf.getvalue()
+        with gzip.GzipFile(fileobj=buf) as go:
+            rd=go.read()
+        print(wd,rd)
+        #12
+        with open(r"r:\j12.gz","wb") as fo:
+            fo
+    def j2():#print sorted punctuation
+        "explorer '- !#$%&(),.;@[]^_`{}~+=0"#'- is ordered by following sign
+        cant=r'"*./:<>?\|'#'unaviable'
+        az="!#$%&'()+,-019;=@AZ[]^_`az{}~"#aviable
+        #
+        import os, time
+        if not(wr.ifexist(r"r:\fn")):os.makedirs(r"r:\fn")
+        #
+        diLe={"a":string.ascii_letters, "d": string.digits,   "p":string.punctuation}
+        li1=[i for j in diLe.values() for i in j]+list("わあ")
+        li1.sort()
+        print(jw("",li1))
+        print(jw("",[ c for c in li1 if not c in cant]))
+        #
+        eFn=[]
+        for i,c in enumerate(li1):
+            if(c in r'"*/:<>?\|'):continue
+            try:
+                fn1=r"r:\fn\%s_d_x%x"%(c,i,ord(c))
+                wr.write8(fn1+".exe","")#exe 4 sendto
+                wr.write8(r"r:\fn\%c"%(c)+".exe","")
+##                os.utime(fn1,(time.mktime((2000,1,1,5,55,55,1,1,1)),0.0))
+            except Exception as e:# lkFileNotFoundError as e:
+                eFn.append((c,e))
+        print("eFn " + jw("",(c for c,e in eFn)))
+    ap=r"N:\driveK\applic\7za920\7za.exe"
+    def j4(fn=r"N:\afilen\program\python\Mjmoji",alias="files",pwd=""):#7z
+        with wr.cldir(fn):
+            fd=os.walk(fn)
+            fn1=[jofn(r,f) for r,ds,fs in fd  for f in fs]
+            fn2=[os.path.relpath(j) for j in fn1]
+            if 1:
+##                fnt=[(f,os.path.split(f)[1]) for f in fn1]
+                fnt=[(f,os.path.relpath(f)) for f in fn1]
+                buf=codetar(fnt,mode="w|")
+                xz=r"r:\tar.tar.xz"
+                codetar(fnt,mode="w|xz",fn=xz)#idea. encoding="utf-8"
+                #
+##                codetar([(fp,"alfa\\"+rp)for fp,rp in fnt],mode="a",fn=r"r:\alf.tar.gz")
+                tarprint(xz)
+                #open
+##                with open(xz+"2","wb") as fo:
+##                    fo
+            fns=fn2
+            j=fns[9]
+            cline=[ap,'a', 'r:\\j4.7z','-si']
+            print(cline)
+            ri=ctod(cline,sh=False,si=buf.getvalue())
+            print(jw(" ",[str(j)for j in ri]))
+    def j3(fn=r"N:\afilen\program\python\file",alias="files",pwd=""):#7z
+        with wr.cldir(fn):
+            ap=r"N:\driveK\applic\7za920\7za.exe"
+            #fns=os.listdir(fn);
+            fd=os.walk(fn)
+            fn1=[jofn(r,f) for r,ds,fs in fd  for f in fs]
+            fn2=[os.path.relpath(j) for j in fn1]
+            fns=fn2
+##            jf=jw(" ",[jofn(fn,j)for j in fns])
+####            print(jf)
+##            cline=ap+" a "+("-p%s "%pwd if pwd else "")+r"r:\j.7z "+jf
+    ##        ri=ctod(cline)
+    ##        print(ri)
+##            cline=ap+" a "+("-p%s "%pwd if pwd else "")+r"r:\stdin.7z -siSI/a "+jf
+####            cline=ap+" a "+("-p%s "%pwd if pwd else "")+r'r:\stdin.7z -sir@list < '+jf
+##            cline=ap+" a "+("-p%s "%pwd if pwd else "")+r'r:\stdin.7z kakomj/mj.py'#idea
+            if 0:
+                ri=ctod(cline)
+            else:
+                for j in fns:
+                    cline=ap+" a "+("-p%s "%pwd if pwd else "")+r"r:\j.7z "+'"%s"'%j
+                    cline=[ap," a "+("-p%s "%pwd if pwd else "")+r"r:\j.7z "+'%s'%j]
+                    cline=[ap,'a', 'r:\\j32.7z',j]#idea
+                    print(cline)
+                    ri=ctod(cline,sh=False)
+                    print(ri)
+##                    wr.prexit()
+            print(ri)
+        #
+        if 0:#no
+            cline=ap+" a "+("-p%s "%pwd if 0 else "")+r"r:/j3.7z "+r"-ir!N:\afilen\program\python\file\*.txt"
+            cline=ap+" a "+r" r:/j2.7z "+r" -ir!R:\temp\*.txt"#idea
+            cline=ap+" a "+r" j2 "+r' -ir!"N:\afilen\program\python\file\*.txt"'
+##            cline=ap+" a "+r" j2 "+r' -ir!"N:/afilen/program/python/file/*.txt"'
+            print(cline)
+            ri=ctod(cline)
+            print(ri)
+##    j4(fn=r"N:\afilen\program\python\file")
+##    j3()
+##    j2()
+##    j1()
+    if hh.mojibake:
+        zfn=r"C:\v\jd\Pic201377.zip"
+        info=zipread(zfn)
+        print(info)
+        #
+        with zipfile.ZipFile(zfn,"r") as zfo:
+            for im in zfo.infolist():#|namelist()
+                fn=im.filename
+                print(fn.encode('cp437').decode('cp932'))
+def m0():
+    te=wr.rfdb(r"N:\afilen\program\python\work\d.html")
+##    buf = StringIO( te.decode("utf-8"))
+    buf = BytesIO( te)
+    f = gzip.GzipFile(fileobj=buf)
+    data = f.read()
+
+    f = open("tenkaiAfter"+".html","wb")
+    f.write(data)
+    f.close()
+
+
+if __name__ == '__main__':
+    main()