copyparty 1.15.2__py3-none-any.whl → 1.15.4__py3-none-any.whl

copyparty/szip.py

@@ -99,7 +99,7 @@ def gen_hdr(
     ret += spack(b"<LL", vsz, vsz)
 
     # windows support (the "?" replace below too)
-    fn = sanitize_fn(fn, "/", [])
+    fn = sanitize_fn(fn, "/")
     bfn = fn.encode("utf-8" if utf8 else "cp437", "replace").replace(b"?", b"_")
 
     # add ntfs (0x24) and/or unix (0x10) extrafields for utc, add z64 if requested

copyparty/u2idx.py

@@ -50,6 +50,7 @@ class U2idx(object):
             self.log("your python does not have sqlite3; searching will be disabled")
             return
 
+
         self.active_id = ""
         self.active_cur  = None
         self.cur   = {}

copyparty/up2k.py

@@ -285,7 +285,9 @@ class Up2k(object):
         else:
             mtpq = "(?)"
             if up_en:
-                ups = [(0, 0, time.time(), "cannot show list (server too busy)")]
+                ups = [(1, 0, 0, time.time(), "cannot show list (server too busy)")]
+                if PY2:
+                    ups = []
 
         ups.sort(reverse=True)
 
@@ -322,7 +324,7 @@ class Up2k(object):
                 zt = (
                     ineed / ihash,
                     job["size"],
-                    int(job["t0"]),
+                    int(job["t0c"]),
                     int(job["poke"]),
                     djoin(vtop, job["prel"], job["name"]),
                 )
@@ -358,10 +360,9 @@ class Up2k(object):
                     continue
                 addr = (ip or "\n") if cfg in (1, 2) else ""
                 user = (uname or "\n") if cfg in (1, 3) else ""
-                drp = self.droppable.get(ptop, {})
-                for wark, job in tab2.items():
+                for job in tab2.values():
                     if (
-                        wark in drp
+                        "done" in job
                         or (user and user != job["user"])
                         or (addr and addr != job["addr"])
                     ):
@@ -402,9 +403,8 @@ class Up2k(object):
             for ptop, tab2 in self.registry.items():
                 nbytes = 0
                 nfiles = 0
-                drp = self.droppable.get(ptop, {})
-                for wark, job in tab2.items():
-                    if wark in drp:
+                for job in tab2.values():
+                    if "done" in job:
                         continue
 
                     nfiles += 1
@@ -1048,6 +1048,7 @@ class Up2k(object):
 
         reg = {}
         drp = None
+        emptylist = []
         snap = os.path.join(histpath, "up2k.snap")
         if bos.path.exists(snap):
             with gzip.GzipFile(snap, "rb") as f:
@@ -1064,6 +1065,9 @@ class Up2k(object):
                 fp = djoin(job["ptop"], job["prel"], job["name"])
                 if bos.path.exists(fp):
                     reg[k] = job
+                    if "done" in job:
+                        job["need"] = job["hash"] = emptylist
+                        continue
                     job["poke"] = time.time()
                     job["busy"] = {}
                 else:
@@ -2758,7 +2762,7 @@ class Up2k(object):
             if ptop not in self.registry:
                 raise Pebkac(410, "location unavailable")
 
-        cj["name"] = sanitize_fn(cj["name"], "", [".prologue.html", ".epilogue.html"])
+        cj["name"] = sanitize_fn(cj["name"], "")
         cj["poke"] = now = self.db_act = self.vol_act[ptop] = time.time()
         wark = self._get_wark(cj)
         job = None
@@ -3003,7 +3007,7 @@ class Up2k(object):
 
                         job = deepcopy(job)
                         job["wark"] = wark
-                        job["at"] = cj.get("at") or time.time()
+                        job["at"] = cj.get("at") or now
                         zs = "vtop ptop prel name lmod host user addr poke"
                         for k in zs.split():
                             job[k] = cj.get(k) or ""
@@ -3328,6 +3332,9 @@ class Up2k(object):
                 self.log("unknown wark [{}], known: {}".format(wark, known))
                 raise Pebkac(400, "unknown wark" + SSEELOG)
 
+            if "t0c" not in job:
+                job["t0c"] = time.time()
+
             if len(chashes) > 1 and len(chashes[1]) < 44:
                 # first hash is full-length; expand remaining ones
                 uniq = []
@@ -3508,7 +3515,11 @@ class Up2k(object):
         if self.idx_wark(vflags, *z2):
             del self.registry[ptop][wark]
         else:
-            self.registry[ptop][wark]["done"] = 1
+            for k in "host tnam busy sprs poke t0c".split():
+                del job[k]
+            job["t0"] = int(job["t0"])
+            job["hash"] = []
+            job["done"] = 1
             self.regdrop(ptop, wark)
 
         if wake_sr:
@@ -4695,7 +4706,11 @@ class Up2k(object):
                     bos.unlink(path)
             return
 
-        newest = float(max(x["poke"] for _, x in reg.items()) if reg else 0)
+        newest = float(
+            max(x["t0"] if "done" in x else x["poke"] for _, x in reg.items())
+            if reg
+            else 0
+        )
         etag = (len(reg), newest)
         if etag == self.snap_prev.get(ptop):
             return
@@ -4706,12 +4721,15 @@ class Up2k(object):
         path2 = "{}.{}".format(path, os.getpid())
         body = {"droppable": self.droppable[ptop], "registry": reg}
         j = json.dumps(body, sort_keys=True, separators=(",\n", ": ")).encode("utf-8")
+        # j = re.sub(r'"(need|hash)": \[\],\n', "", j)  # bytes=slow, utf8=hungry
+        j = j.replace(b'"need": [],\n', b"")  # surprisingly optimal
+        j = j.replace(b'"hash": [],\n', b"")
         with gzip.GzipFile(path2, "wb") as f:
             f.write(j)
 
         atomic_move(self.log, path2, path, VF_CAREFUL)
 
-        self.log("snap: {} |{}|".format(path, len(reg.keys())))
+        self.log("snap: %s |%d| %.2fs" % (path, len(reg), time.time() - now))
         self.snap_prev[ptop] = etag
 
     def _tagger(self)  :

copyparty/util.py

@@ -4,6 +4,7 @@ from __future__ import print_function, unicode_literals
 import argparse
 import base64
 import binascii
+import codecs
 import errno
 import hashlib
 import hmac
@@ -30,7 +31,17 @@ from collections import Counter
 from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network
 from queue import Queue
 
-from .__init__ import ANYWIN, EXE, MACOS, PY2, PY36, TYPE_CHECKING, VT100, WINDOWS
+from .__init__ import (
+    ANYWIN,
+    EXE,
+    MACOS,
+    PY2,
+    PY36,
+    TYPE_CHECKING,
+    VT100,
+    WINDOWS,
+    EnvParams,
+)
 from .__version__ import S_BUILD_DT, S_VERSION
 from .stolen import surrogateescape
 
@@ -258,6 +269,30 @@ if ANYWIN:
 UNPLICATIONS = [["no_dav", "daw"]]
 
 
+DAV_ALLPROP_L = [
+    "contentclass",
+    "creationdate",
+    "defaultdocument",
+    "displayname",
+    "getcontentlanguage",
+    "getcontentlength",
+    "getcontenttype",
+    "getlastmodified",
+    "href",
+    "iscollection",
+    "ishidden",
+    "isreadonly",
+    "isroot",
+    "isstructureddocument",
+    "lastaccessed",
+    "name",
+    "parentname",
+    "resourcetype",
+    "supportedlock",
+]
+DAV_ALLPROPS = set(DAV_ALLPROP_L)
+
+
 MIMES = {
     "opus": "audio/ogg; codecs=opus",
 }
@@ -728,60 +763,6 @@ class _Unrecv(object):
         self.buf = buf + self.buf
 
 
-class _LUnrecv(object):
-    """
-    with expensive debug logging
-    """
-
-    def __init__(self, s , log )  :
-        self.s = s
-        self.log = log
-        self.buf = b""
-
-    def recv(self, nbytes , spins )  :
-        if self.buf:
-            ret = self.buf[:nbytes]
-            self.buf = self.buf[nbytes:]
-            t = "\033[0;7mur:pop:\033[0;1;32m {}\n\033[0;7mur:rem:\033[0;1;35m {}\033[0m"
-            print(t.format(ret, self.buf))
-            return ret
-
-        ret = self.s.recv(nbytes)
-        t = "\033[0;7mur:recv\033[0;1;33m {}\033[0m"
-        print(t.format(ret))
-        if not ret:
-            raise UnrecvEOF("client stopped sending data")
-
-        return ret
-
-    def recv_ex(self, nbytes , raise_on_trunc  = True)  :
-        """read an exact number of bytes"""
-        try:
-            ret = self.recv(nbytes, 1)
-            err = False
-        except:
-            ret = b""
-            err = True
-
-        while not err and len(ret) < nbytes:
-            try:
-                ret += self.recv(nbytes - len(ret), 1)
-            except OSError:
-                err = True
-
-        if err:
-            t = "client only sent {} of {} expected bytes".format(len(ret), nbytes)
-            if raise_on_trunc:
-                raise UnrecvEOF(t)
-            elif self.log:
-                self.log(t, 3)
-
-        return ret
-
-    def unrecv(self, buf )  :
-        self.buf = buf + self.buf
-        t = "\033[0;7mur:push\033[0;1;31m {}\n\033[0;7mur:rem:\033[0;1;35m {}\033[0m"
-        print(t.format(buf, self.buf))
 
 
 Unrecv = _Unrecv
@@ -1916,13 +1897,10 @@ def undot(path )  :
     return "/".join(ret)
 
 
-def sanitize_fn(fn , ok , bad )  :
+def sanitize_fn(fn , ok )  :
     if "/" not in ok:
         fn = fn.replace("\\", "/").split("/")[-1]
 
-    if fn.lower() in bad:
-        fn = "_" + fn
-
     if ANYWIN:
         remap = [
             ["<", "＜"],
@@ -1948,9 +1926,9 @@ def sanitize_fn(fn , ok , bad )  :
     return fn.strip()
 
 
-def sanitize_vpath(vp , ok , bad )  :
+def sanitize_vpath(vp , ok )  :
     parts = vp.replace(os.sep, "/").split("/")
-    ret = [sanitize_fn(x, ok, bad) for x in parts]
+    ret = [sanitize_fn(x, ok) for x in parts]
     return "/".join(ret)
 
 
@@ -3376,9 +3354,15 @@ def loadpy(ap , hot )  :
 
 def gzip_orig_sz(fn )  :
     with open(fsenc(fn), "rb") as f:
-        f.seek(-4, 2)
-        rv = f.read(4)
-        return sunpack(b"I", rv)[0]  # type: ignore
+        return gzip_file_orig_sz(f)
+
+
+def gzip_file_orig_sz(f)  :
+    start = f.tell()
+    f.seek(-4, 2)
+    rv = f.read(4)
+    f.seek(start, 0)
+    return sunpack(b"I", rv)[0]  # type: ignore
 
 
 def align_tab(lines )  :
@@ -3513,6 +3497,103 @@ def hidedir(dp)  :
             pass
 
 
+try:
+    if sys.version_info < (3, 10):
+        # py3.8 doesn't have .files
+        # py3.9 has broken .is_file
+        raise ImportError()
+    import importlib.resources as impresources
+except ImportError:
+    try:
+        import importlib_resources as impresources
+    except ImportError:
+        impresources = None
+try:
+    if sys.version_info > (3, 10):
+        raise ImportError()
+    import pkg_resources
+except ImportError:
+    pkg_resources = None
+
+
+def _pkg_resource_exists(pkg , name )  :
+    if not pkg_resources:
+        return False
+    try:
+        return pkg_resources.resource_exists(pkg, name)
+    except NotImplementedError:
+        return False
+
+
+def stat_resource(E , name ):
+    path = os.path.join(E.mod, name)
+    if os.path.exists(path):
+        return os.stat(fsenc(path))
+    return None
+
+
+def _find_impresource(E , name ):
+    try:
+        files = impresources.files(E.pkg)
+    except ImportError:
+        return None
+
+    return files.joinpath(name)
+
+
+_rescache_has = {}
+
+
+def _has_resource(E , name ):
+    try:
+        return _rescache_has[name]
+    except:
+        pass
+
+    if len(_rescache_has) > 999:
+        _rescache_has.clear()
+
+    if impresources:
+        res = _find_impresource(E, name)
+        if res and res.is_file():
+            _rescache_has[name] = True
+            return True
+
+    if pkg_resources:
+        if _pkg_resource_exists(E.pkg.__name__, name):
+            _rescache_has[name] = True
+            return True
+
+    _rescache_has[name] = False
+    return False
+
+
+def has_resource(E , name ):
+    return _has_resource(E, name) or os.path.exists(os.path.join(E.mod, name))
+
+
+def load_resource(E , name , mode="rb")  :
+    enc = None if "b" in mode else "utf-8"
+
+    if impresources:
+        res = _find_impresource(E, name)
+        if res and res.is_file():
+            if enc:
+                return res.open(mode, encoding=enc)
+            else:
+                # throws if encoding= is mentioned at all
+                return res.open(mode)
+
+    if pkg_resources:
+        if _pkg_resource_exists(E.pkg.__name__, name):
+            stream = pkg_resources.resource_stream(E.pkg.__name__, name)
+            if enc:
+                stream = codecs.getreader(enc)(stream)
+            return stream
+
+    return open(os.path.join(E.mod, name), mode, encoding=enc)
+
+
 class Pebkac(Exception):
     def __init__(
         self, code , msg  = None, log  = None