SYMBOL INDEX (2403 symbols across 162 files)

FILE: bin/dbtool.py
  function die (line 17) | def die(msg):
  function read_ver (line 22) | def read_ver(db):
  function ls (line 36) | def ls(db):
  function compare (line 50) | def compare(n1, d1, n2, d2, verbose):
  function copy_mtp (line 145) | def copy_mtp(d1, d2, tag, rm):
  function examples (line 193) | def examples():
  function main (line 209) | def main():

FILE: bin/handlers/caching-proxy.py
  function main (line 14) | def main(cli: "HttpCli", vn, rem):

FILE: bin/handlers/ip-ok.py
  function main (line 4) | def main(cli, vn, rem):

FILE: bin/handlers/never404.py
  function main (line 4) | def main(cli, vn, rem):

FILE: bin/handlers/nooo.py
  function say_no (line 4) | def say_no():
  function main (line 10) | def main(cli, vn, rem):

FILE: bin/handlers/randpic.py
  function main (line 12) | def main(cli, vn, rem):

FILE: bin/handlers/redirect.py
  function send_http_302_temporary_redirect (line 4) | def send_http_302_temporary_redirect(cli, new_path):
  function send_http_301_permanent_redirect (line 15) | def send_http_301_permanent_redirect(cli, new_path):
  function send_errorpage_with_redirect_link (line 23) | def send_errorpage_with_redirect_link(cli, new_path):
  function main (line 33) | def main(cli, vn, rem):

FILE: bin/handlers/sorry.py
  function main (line 4) | def main(cli, vn, rem):

FILE: bin/hooks/discord-announce.py
  function main (line 46) | def main():

FILE: bin/hooks/image-noexif.py
  function fsenc (line 41) | def fsenc(p):
  function main (line 45) | def main():

FILE: bin/hooks/import-me.py
  function main (line 41) | def main(ka: dict[str, Any]) -> dict[str, Any]:

FILE: bin/hooks/into-the-cache-it-goes.py
  function main (line 79) | def main():
  function download_with_curl (line 104) | def download_with_curl(url, pw):
  function download_with_wget (line 114) | def download_with_wget(url, pw):
  function download_with_python (line 126) | def download_with_python(url, pw):

FILE: bin/hooks/msg-log.py
  function write_ascending (line 69) | def write_ascending(filepath, msg_text):
  function write_descending (line 74) | def write_descending(filepath, msg_text):
  function main (line 109) | def main(argv=None):

FILE: bin/hooks/notify.py
  function humansize (line 37) | def humansize(n):
  function main (line 41) | def main():

FILE: bin/hooks/notify2.py
  function humansize (line 37) | def humansize(n):
  function main (line 41) | def main():

FILE: bin/hooks/podcast-normalizer.py
  function fsenc (line 68) | def fsenc(p):
  function main (line 72) | def main():

FILE: bin/hooks/qbittorrent-magnet.py
  function main (line 68) | def main():

FILE: bin/hooks/reject-and-explain.py
  function main (line 39) | def main():

FILE: bin/hooks/reject-extension.py
  function main (line 26) | def main():

FILE: bin/hooks/reject-mimetype.py
  function main (line 33) | def main():

FILE: bin/hooks/reject-ramdisk.py
  function main (line 52) | def main(ka: dict[str, Any]) -> dict[str, Any]:

FILE: bin/hooks/reloc-by-ext.py
  function main (line 49) | def main():

FILE: bin/hooks/usb-eject.js
  function usbclick (line 3) | function usbclick() {
  function eject_cb (line 9) | function eject_cb() {
  function add_eject_2 (line 18) | function add_eject_2(a) {
  function add_eject (line 47) | function add_eject() {

FILE: bin/hooks/usb-eject.py
  function main (line 35) | def main():

FILE: bin/hooks/wget-i.py
  function do_stuff (line 54) | def do_stuff(inf):
  function main (line 99) | def main(inf):

FILE: bin/hooks/wget.py
  function main (line 47) | def main():

FILE: bin/hooks/xiu-sha.py
  function fsenc (line 42) | def fsenc(p):
  function humantime (line 49) | def humantime(ts):
  function find_files_root (line 53) | def find_files_root(inf):
  function find_vol_root (line 64) | def find_vol_root(inf):
  function main (line 68) | def main():

FILE: bin/hooks/xiu.py
  function main (line 35) | def main():

FILE: bin/mtag/audio-bpm.py
  function det (line 23) | def det(tf):
  function main (line 78) | def main():

FILE: bin/mtag/audio-key-slicing.py
  function get_duration (line 26) | def get_duration():
  function get_segs (line 46) | def get_segs(dur):
  function slice (line 63) | def slice(tf):
  function det (line 105) | def det(tf):
  function main (line 110) | def main():

FILE: bin/mtag/audio-key.py
  function det (line 29) | def det(tf):
  function main (line 57) | def main():

FILE: bin/mtag/cksum.py
  function fsenc (line 18) | def fsenc(p):
  function main (line 28) | def main():

FILE: bin/mtag/exe.py
  function unk (line 14) | def unk(v):
  class PE2 (line 18) | class PE2(pefile.PE):
    method __init__ (line 19) | def __init__(self, *a, **ka):
    method noop (line 38) | def noop(*a, **ka):

FILE: bin/mtag/geotag.py
  function main (line 23) | def main():

FILE: bin/mtag/guestbook-read.py
  function main (line 38) | def main():

FILE: bin/mtag/guestbook.py
  function main (line 43) | def main():

FILE: bin/mtag/image-noexif.py
  function fsenc (line 53) | def fsenc(p):
  function main (line 57) | def main():

FILE: bin/mtag/media-hash.py
  function fsenc (line 15) | def fsenc(p):
  function det (line 24) | def det():
  function main (line 65) | def main():

FILE: bin/mtag/mousepad.py
  function main (line 23) | def main():

FILE: bin/mtag/rclone-upload.py
  function fsenc (line 13) | def fsenc(p):
  function main (line 49) | def main():

FILE: bin/mtag/res/twitter-unmute.user.js
  function grunnur (line 12) | function grunnur() {

FILE: bin/mtag/res/yt-ipr.user.js
  function main (line 9) | function main() {

FILE: bin/mtag/very-bad-idea.py
  function main (line 97) | def main():
  function open_post (line 115) | def open_post(txt):
  function open_url (line 142) | def open_url(txt):
  function try_mpv (line 175) | def try_mpv(url):
  function try_streamlink (line 187) | def try_streamlink(url):

FILE: bin/mtag/vidchk.py
  function fsenc (line 13) | def fsenc(p):
  function wfilter (line 46) | def wfilter(lines):
  function errchk (line 50) | def errchk(so, se, rc, dbg):
  function main (line 69) | def main():

FILE: bin/mtag/wget.py
  function main (line 37) | def main():

FILE: bin/mtag/yt-ipr.py
  function main (line 29) | def main():
  function get_expiration (line 52) | def get_expiration(url):
  function parse_youtube (line 58) | def parse_youtube(pd):
  function parse_freg (line 87) | def parse_freg(pd):
  function freg_conv (line 99) | def freg_conv(pd):

FILE: bin/partyfuse-streaming.py
  function print (line 74) | def print(*args, **kwargs):
  function termsafe (line 81) | def termsafe(txt):
  function threadless_log (line 90) | def threadless_log(msg):
  function boring_log (line 94) | def boring_log(msg):
  function rice_tid (line 99) | def rice_tid():
  function fancy_log (line 105) | def fancy_log(msg):
  function null_log (line 109) | def null_log(msg):
  function hexler (line 113) | def hexler(binary):
  function register_wtf8 (line 119) | def register_wtf8():
  function enwin (line 136) | def enwin(txt):
  function dewin (line 145) | def dewin(txt):
  class RecentLog (line 154) | class RecentLog(object):
    method __init__ (line 155) | def __init__(self):
    method put (line 164) | def put(self, msg):
    method printer (line 175) | def printer(self):
  function html_dec (line 208) | def html_dec(txt):
  class CacheNode (line 219) | class CacheNode(object):
    method __init__ (line 220) | def __init__(self, tag, data):
  class Gateway (line 226) | class Gateway(object):
    method __init__ (line 227) | def __init__(self, ar):
    method quotep (line 263) | def quotep(self, path):
    method newconn (line 267) | def newconn(self):
    method getconn_unix (line 285) | def getconn_unix(self, key=None):
    method getconn_winfsp (line 294) | def getconn_winfsp(self, key="x"):
    method putconn_winfsp (line 328) | def putconn_winfsp(self, c, path):
    method closeconn (line 332) | def closeconn(self, c):
    method sendreq (line 349) | def sendreq(self, meth, path, headers, **kwargs):
    method listdir (line 385) | def listdir(self, path):
    method download_file_range (line 414) | def download_file_range(self, path, ofs1, ofs2):
    method parse_html (line 462) | def parse_html(self, datasrc):
    method stat_dir (line 511) | def stat_dir(self, ts, sz=4096):
    method stat_file (line 523) | def stat_file(self, ts, sz):
  class CPPF (line 536) | class CPPF(Operations):
    method __init__ (line 537) | def __init__(self, ar):
    method _describe (line 551) | def _describe(self):
    method clean_dircache (line 566) | def clean_dircache(self):
    method get_cached_dir (line 579) | def get_cached_dir(self, dirpath):
    method get_cached_file (line 613) | def get_cached_file(self, path, get1, get2, file_sz):
    method _readdir (line 802) | def _readdir(self, path, fh=None):
    method readdir (line 817) | def readdir(self, path, fh=None):
    method read (line 820) | def read(self, path, length, offset, fh=None):
    method getattr (line 873) | def getattr(self, path, fh=None):
    method access (line 927) | def access(self, path, mode):
    method flush (line 931) | def flush(self, path, fh):
    method getxattr (line 935) | def getxattr(self, *args):
    method listxattr (line 939) | def listxattr(self, *args):
    method open (line 943) | def open(self, path, flags):
    method opendir (line 947) | def opendir(self, fh):
    method release (line 951) | def release(self, ino, fi):
    method releasedir (line 955) | def releasedir(self, ino, fi):
    method statfs (line 959) | def statfs(self, path):
    method _open (line 965) | def _open(self, path):
    method open (line 981) | def open(self, path, flags):
    method opendir (line 985) | def opendir(self, path):
    method flush (line 989) | def flush(self, path, fh):
    method release (line 992) | def release(self, ino, fi):
    method releasedir (line 995) | def releasedir(self, ino, fi):
    method access (line 998) | def access(self, path, mode):
  class TheArgparseFormatter (line 1008) | class TheArgparseFormatter(
  function main (line 1014) | def main():

FILE: bin/partyfuse.py
  function print (line 70) | def print(*args, **kwargs):
  function nullfun (line 86) | def nullfun(*a):
  function termsafe (line 113) | def termsafe(txt):
  function threadless_log (line 121) | def threadless_log(fmt, *a):
  function rice_tid (line 129) | def rice_tid():
  function fancy_log (line 140) | def fancy_log(fmt, *a):
  function register_wtf8 (line 145) | def register_wtf8():
  function enwin (line 162) | def enwin(txt):
  function dewin (line 166) | def dewin(txt):
  class RecentLog (line 170) | class RecentLog(object):
    method __init__ (line 171) | def __init__(self, ar):
    method put (line 181) | def put(self, fmt, *a):
    method printer (line 200) | def printer(self):
  function get_tid (line 233) | def get_tid():
  function html_dec (line 237) | def html_dec(txt):
  class CacheNode (line 248) | class CacheNode(object):
    method __init__ (line 249) | def __init__(self, tag, data):
  class Gateway (line 255) | class Gateway(object):
    method __init__ (line 256) | def __init__(self, ar):
    method quotep (line 327) | def quotep(self, path):
    method getconn (line 331) | def getconn(self, tid=None):
    method closeconn (line 351) | def closeconn(self, tid=None):
    method sendreq (line 359) | def sendreq(self, meth, path, headers, **kwargs):
    method listdir (line 386) | def listdir(self, path):
    method download_file_range (line 416) | def download_file_range(self, path, ofs1, ofs2):
    method parse_jls (line 435) | def parse_jls(self, sck):
    method parse_cpp (line 462) | def parse_cpp(self, sck):
    method parse_nginx (line 510) | def parse_nginx(self, sck):
    method parse_iis (line 559) | def parse_iis(self, sck):
    method stat_dir (line 614) | def stat_dir(self, ts, sz):
    method stat_file (line 626) | def stat_file(self, ts, sz):
  class CPPF (line 639) | class CPPF(Operations):
    method __init__ (line 640) | def __init__(self, ar):
    method _describe (line 655) | def _describe(self):
    method clean_dircache (line 671) | def clean_dircache(self):
    method get_cached_dir (line 685) | def get_cached_dir(self, dirpath):
    method get_cached_file (line 721) | def get_cached_file(self, path, get1, get2, file_sz):
    method _readdir (line 904) | def _readdir(self, path, fh=None):
    method readdir (line 917) | def readdir(self, path, fh=None):
    method read (line 927) | def read(self, path, length, offset, fh=None):
    method getattr (line 979) | def getattr(self, path, fh=None):
    method access (line 1029) | def access(self, path, mode):
    method flush (line 1033) | def flush(self, path, fh):
    method getxattr (line 1037) | def getxattr(self, *args):
    method listxattr (line 1041) | def listxattr(self, *args):
    method open (line 1045) | def open(self, path, flags):
    method opendir (line 1049) | def opendir(self, fh):
    method release (line 1053) | def release(self, ino, fi):
    method releasedir (line 1057) | def releasedir(self, ino, fi):
    method statfs (line 1061) | def statfs(self, path):
    method _open (line 1069) | def _open(self, path):
    method open (line 1085) | def open(self, path, flags):
    method opendir (line 1089) | def opendir(self, path):
    method flush (line 1093) | def flush(self, path, fh):
    method release (line 1096) | def release(self, ino, fi):
    method releasedir (line 1099) | def releasedir(self, ino, fi):
    method access (line 1102) | def access(self, path, mode):
  class TheArgparseFormatter (line 1112) | class TheArgparseFormatter(
  function main (line 1118) | def main():

FILE: bin/partyfuse2.py
  function threadless_log (line 71) | def threadless_log(msg):
  function boring_log (line 75) | def boring_log(msg):
  function rice_tid (line 80) | def rice_tid():
  function fancy_log (line 86) | def fancy_log(msg):
  function null_log (line 90) | def null_log(msg):
  function get_tid (line 101) | def get_tid():
  function html_dec (line 105) | def html_dec(txt):
  function register_wtf8 (line 114) | def register_wtf8():
  function enwin (line 131) | def enwin(txt):
  function dewin (line 140) | def dewin(txt):
  class CacheNode (line 149) | class CacheNode(object):
    method __init__ (line 150) | def __init__(self, tag, data):
  class Stat (line 156) | class Stat(fuse.Stat):
    method __init__ (line 157) | def __init__(self):
  class Gateway (line 170) | class Gateway(object):
    method __init__ (line 171) | def __init__(self, base_url, pw):
    method quotep (line 191) | def quotep(self, path):
    method getconn (line 195) | def getconn(self, tid=None):
    method closeconn (line 207) | def closeconn(self, tid=None):
    method sendreq (line 215) | def sendreq(self, *args, **ka):
    method listdir (line 233) | def listdir(self, path):
    method download_file_range (line 249) | def download_file_range(self, path, ofs1, ofs2):
    method parse_jls (line 268) | def parse_jls(self, datasrc):
    method stat_dir (line 292) | def stat_dir(self, ts, sz=4096):
    method stat_file (line 302) | def stat_file(self, ts, sz):
  class CPPF (line 312) | class CPPF(Fuse):
    method __init__ (line 313) | def __init__(self, *args, **kwargs):
    method init2 (line 325) | def init2(self):
    method clean_dircache (line 330) | def clean_dircache(self):
    method get_cached_dir (line 343) | def get_cached_dir(self, dirpath):
    method get_cached_file (line 378) | def get_cached_file(self, path, get1, get2, file_sz):
    method _readdir (line 533) | def _readdir(self, path):
    method readdir (line 547) | def readdir(self, path, offset):
    method open (line 552) | def open(self, path, flags):
    method read (line 563) | def read(self, path, length, offset, fh=None, *args):
    method getattr (line 590) | def getattr(self, path):
  function main (line 624) | def main():

FILE: bin/partyjournal.py
  class APF (line 32) | class APF(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptio...
  function s3dec (line 40) | def s3dec(v):
  function quotep (line 48) | def quotep(txt):
  function html_escape (line 56) | def html_escape(s, quote=False, crlf=False):
  function main (line 71) | def main():

FILE: bin/u2c.py
  class _UTC (line 78) | class _UTC(datetime.tzinfo):
    method utcoffset (line 79) | def utcoffset(self, dt):
    method tzname (line 82) | def tzname(self, dt):
    method dst (line 85) | def dst(self, dt):
  function ub64enc (line 94) | def ub64enc(bs):
  class Fatal (line 103) | class Fatal(Exception):
  class Daemon (line 107) | class Daemon(threading.Thread):
    method __init__ (line 108) | def __init__(self, target, name=None, a=None):
    method run (line 115) | def run(self):
  class HSQueue (line 124) | class HSQueue(Queue):
    method _init (line 125) | def _init(self, maxsize):
    method _qsize (line 130) | def _qsize(self):
    method _put (line 133) | def _put(self, item):
    method _get (line 139) | def _get(self):
  class HCli (line 143) | class HCli(object):
    method __init__ (line 144) | def __init__(self, ar):
    method _connect (line 179) | def _connect(self, timeout):
    method req (line 193) | def req(self, meth, vpath, hdrs, body=None, ctype=None):
  class File (line 247) | class File(object):
    method __init__ (line 250) | def __init__(self, top, rel, size, lmod):
  class FileSlice (line 280) | class FileSlice(object):
    method __init__ (line 283) | def __init__(self, file, cids):
    method subchunk (line 304) | def subchunk(self, maxsz, nth):
    method unsub (line 321) | def unsub(self):
    method _open (line 326) | def _open(self):
    method close (line 342) | def close(self, *a, **ka):
    method tell (line 345) | def tell(self):
    method _seek (line 348) | def _seek(self, ofs, wh=0):
    method _read (line 364) | def _read(self, sz):
    method _seek0 (line 372) | def _seek0(self, ofs, wh=0):
    method _read0 (line 376) | def _read0(self, sz):
  class MTHash (line 381) | class MTHash(object):
    method __init__ (line 382) | def __init__(self, cores):
    method hash (line 394) | def hash(self, f, fsz, chunksz, pcb=None, pcb_opaque=None):
    method worker (line 429) | def worker(self):
    method hash_at (line 439) | def hash_at(self, nch):
  function safe_print (line 464) | def safe_print(*a, **ka):
  function eprint (line 470) | def eprint(*a, **ka):
  function flushing_print (line 481) | def flushing_print(*a, **ka):
  function termsize (line 496) | def termsize():
  class CTermsize (line 531) | class CTermsize(object):
    method __init__ (line 532) | def __init__(self):
    method worker (line 545) | def worker(self):
    method ev_sig (line 557) | def ev_sig(self, *a, **ka):
    method scroll_region (line 560) | def scroll_region(self, margin):
  function undns (line 574) | def undns(url):
  function _scd (line 600) | def _scd(err, top):
  function _lsd (line 612) | def _lsd(err, top):
  function walkdir (line 629) | def walkdir(err, top, excl, seen):
  function walkdirs (line 653) | def walkdirs(err, tops, excl):
  function quotep (line 695) | def quotep(btxt):
  function humansize (line 705) | def humansize(sz, terse=False):
  function up2k_chunksize (line 722) | def up2k_chunksize(filesize):
  function get_hashlist (line 737) | def get_hashlist(file, pcb, mth):
  function printlink (line 781) | def printlink(ar, purl, name, fk):
  function handshake (line 804) | def handshake(ar, file, search):
  function upload (line 896) | def upload(fsl, stats, maxsz):
  class Ctl (line 945) | class Ctl(object):
    method _scan (line 951) | def _scan(self):
    method __init__ (line 984) | def __init__(self, ar, stats=None):
    method _safe (line 1040) | def _safe(self):
    method _fancy (line 1093) | def _fancy(self):
    method cleanup_vt100 (line 1186) | def cleanup_vt100(self):
    method cb_hasher (line 1193) | def cb_hasher(self, file, ofs):
    method hasher (line 1196) | def hasher(self):
    method _check_if_done (line 1331) | def _check_if_done(self):
    method handshaker (line 1338) | def handshaker(self):
    method uploader (line 1459) | def uploader(self):
    method up_done (line 1522) | def up_done(self, file):
  class APF (line 1527) | class APF(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptio...
  function main (line 1531) | def main():

FILE: bin/unforget.py
  class APF (line 27) | class APF(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptio...
  function s3enc (line 35) | def s3enc(rd: str, fn: str) -> tuple[str, str]:
  function main (line 48) | def main():

FILE: bin/zmq-recv.py
  function sub_server (line 35) | def sub_server():
  function pull_server (line 45) | def pull_server():
  function rep_server (line 54) | def rep_server():

FILE: contrib/package/nix/copyparty/update.py
  function get_formatted_hash (line 24) | def get_formatted_hash(binary):
  function version_from_tar_gz (line 32) | def version_from_tar_gz(path):
  function remote_release_pin (line 42) | def remote_release_pin():
  function local_release_pin (line 56) | def local_release_pin(path):
  function main (line 65) | def main():

FILE: contrib/package/nix/partftpy/update.py
  function get_formatted_hash (line 19) | def get_formatted_hash(binary):
  function remote_release_pin (line 27) | def remote_release_pin():
  function main (line 41) | def main():

FILE: contrib/plugins/banner.js
  function bannerdiv (line 24) | function bannerdiv(border) {

FILE: contrib/plugins/meadup.js
  function initKeybaord (line 16) | function initKeybaord(BASE_URL, HAMBAGA, consoleLog, consoleError) {

FILE: contrib/plugins/quickmove.js
  function ask_for_confirmation_and_then_move (line 37) | function ask_for_confirmation_and_then_move() {
  function move_selected_files (line 47) | function move_selected_files() {
  function move_next_file (line 66) | function move_next_file() {
  function our_hotkey_handler (line 102) | function our_hotkey_handler(e) {
  function enable_plugin (line 126) | function enable_plugin() {

FILE: contrib/plugins/rave.js
  function rave_load (line 51) | function rave_load() {
  function rave_unload (line 80) | function rave_unload() {
  function readbeats (line 85) | function readbeats() {
  function hrand (line 105) | function hrand() {
  function raver (line 109) | function raver() {
  function untz (line 192) | function untz() {

FILE: contrib/plugins/up2k-hook-ytid.js
  function up2k_namefilter (line 9) | function up2k_namefilter(good_files, nil_files, bad_files, hooks) {
  function bstrpos (line 19) | function bstrpos(buf, ptn) {
  function a_up2k_namefilter (line 40) | async function a_up2k_namefilter(good_files, nil_files, bad_files, hooks) {

FILE: contrib/plugins/up2k-hooks.js
  function up2k_namefilter (line 3) | function up2k_namefilter(good_files, nil_files, bad_files, hooks) {

FILE: contrib/zfs-tune.py
  function min_ex (line 40) | def min_ex(max_lines: int = 8, reverse: bool = False) -> str:
  function set_pagesize (line 50) | def set_pagesize(db_path):
  function main (line 78) | def main():

FILE: copyparty/__init__.py
  class EnvParams (line 139) | class EnvParams(object):
    method __init__ (line 140) | def __init__(self) -> None:

FILE: copyparty/__main__.py
  class RiceFormatter (line 105) | class RiceFormatter(argparse.HelpFormatter):
    method __init__ (line 106) | def __init__(self, *args: Any, **kwargs: Any) -> None:
    method _get_help_string (line 112) | def _get_help_string(self, action: argparse.Action) -> str:
    method _fill_text (line 133) | def _fill_text(self, text: str, width: int, indent: str) -> str:
    method __add_whitespace (line 137) | def __add_whitespace(self, idx: int, iWSpace: int, text: str) -> str:
    method _split_lines (line 140) | def _split_lines(self, text: str, width: int) -> list[str]:
  class Dodge11874 (line 159) | class Dodge11874(RiceFormatter):
    method __init__ (line 160) | def __init__(self, *args: Any, **kwargs: Any) -> None:
  class BasicDodge11874 (line 165) | class BasicDodge11874(
    method __init__ (line 168) | def __init__(self, *args: Any, **kwargs: Any) -> None:
  function lprint (line 173) | def lprint(*a: Any, **ka: Any) -> None:
  function warn (line 183) | def warn(msg: str) -> None:
  function init_E (line 187) | def init_E(EE: EnvParams) -> None:
  function get_srvname (line 287) | def get_srvname(verbose) -> str:
  function get_salt (line 312) | def get_salt(name: str, nbytes: int) -> str:
  function ensure_locale (line 323) | def ensure_locale() -> None:
  function ensure_webdeps (line 345) | def ensure_webdeps() -> None:
  function configure_ssl_ver (line 361) | def configure_ssl_ver(al: argparse.Namespace) -> None:
  function configure_ssl_ciphers (line 405) | def configure_ssl_ciphers(al: argparse.Namespace) -> None:
  function args_from_cfg (line 430) | def args_from_cfg(cfg_path: str) -> list[str]:
  function expand_cfg (line 459) | def expand_cfg(argv) -> list[str]:
  function quotecheck (line 482) | def quotecheck(al):
  function sighandler (line 497) | def sighandler(sig: Optional[int] = None, frame: Optional[FrameType] = N...
  function disable_quickedit (line 508) | def disable_quickedit() -> None:
  function sfx_tpoke (line 558) | def sfx_tpoke(top: str):
  function showlic (line 577) | def showlic() -> None:
  function get_sects (line 591) | def get_sects():
  function build_flags_desc (line 1170) | def build_flags_desc():
  function add_general (line 1184) | def add_general(ap, nc, srvname):
  function add_qr (line 1212) | def add_qr(ap, tty):
  function add_fs (line 1231) | def add_fs(ap):
  function add_share (line 1242) | def add_share(ap):
  function add_upload (line 1254) | def add_upload(ap):
  function add_network (line 1303) | def add_network(ap):
  function add_tls (line 1335) | def add_tls(ap, cert_path):
  function add_cert (line 1346) | def add_cert(ap, cert_path):
  function add_auth (line 1365) | def add_auth(ap):
  function add_chpw (line 1401) | def add_chpw(ap):
  function add_zeroconf (line 1411) | def add_zeroconf(ap):
  function add_zc_mdns (line 1421) | def add_zc_mdns(ap):
  function add_zc_ssdp (line 1446) | def add_zc_ssdp(ap):
  function add_sftp (line 1456) | def add_sftp(ap):
  function add_ftp (line 1472) | def add_ftp(ap):
  function add_webdav (line 1486) | def add_webdav(ap):
  function add_tftp (line 1499) | def add_tftp(ap):
  function add_smb (line 1513) | def add_smb(ap):
  function add_opds (line 1528) | def add_opds(ap):
  function add_handlers (line 1534) | def add_handlers(ap):
  function add_hooks (line 1541) | def add_hooks(ap):
  function add_stats (line 1557) | def add_stats(ap):
  function add_yolo (line 1568) | def add_yolo(ap):
  function add_optouts (line 1578) | def add_optouts(ap):
  function add_safety (line 1606) | def add_safety(ap):
  function add_salt (line 1643) | def add_salt(ap, fk_salt, dk_salt, ah_salt):
  function add_shutdown (line 1657) | def add_shutdown(ap):
  function add_logging (line 1664) | def add_logging(ap):
  function add_admin (line 1688) | def add_admin(ap):
  function add_thumbnail (line 1702) | def add_thumbnail(ap):
  function add_transcoding (line 1743) | def add_transcoding(ap):
  function add_tail (line 1756) | def add_tail(ap):
  function add_rss (line 1766) | def add_rss(ap):
  function add_db_general (line 1776) | def add_db_general(ap, hcores):
  function add_db_metadata (line 1808) | def add_db_metadata(ap):
  function add_txt (line 1827) | def add_txt(ap):
  function add_og (line 1841) | def add_og(ap):
  function add_ui (line 1859) | def add_ui(ap, retry: int):
  function add_debug (line 1925) | def add_debug(ap):
  function run_argparse (line 1952) | def run_argparse(
  function main (line 2049) | def main(argv: Optional[list[str]] = None) -> None:

FILE: copyparty/authsrv.py
  class CfgEx (line 117) | class CfgEx(Exception):
  class AXS (line 121) | class AXS(object):
    method __init__ (line 122) | def __init__(
    method __repr__ (line 144) | def __repr__(self) -> str:
  class Lim (line 149) | class Lim(object):
    method __init__ (line 150) | def __init__(
    method log (line 191) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method set_rotf (line 195) | def set_rotf(self, fmt: str, tz: str) -> None:
    method all (line 205) | def all(
    method chk_sz (line 237) | def chk_sz(self, sz: int) -> None:
    method chk_vsz (line 244) | def chk_vsz(
    method chk_df (line 263) | def chk_df(self, abspath: str, sz: int, already_written: bool = False)...
    method chk_rem (line 291) | def chk_rem(self, rem: str) -> None:
    method rot (line 295) | def rot(self, path: str) -> tuple[str, str]:
    method dive (line 317) | def dive(self, path: str, lvs: int) -> Optional[str]:
    method nup (line 361) | def nup(self, ip: str) -> None:
    method bup (line 367) | def bup(self, ip: str, nbytes: int) -> None:
    method chk_nup (line 376) | def chk_nup(self, ip: str) -> None:
    method chk_bup (line 388) | def chk_bup(self, ip: str) -> None:
  class VFS (line 403) | class VFS(object):
    method __init__ (line 406) | def __init__(
    method __repr__ (line 471) | def __repr__(self) -> str:
    method get_all_vols (line 479) | def get_all_vols(
    method add (line 502) | def add(self, src: str, dst: str, dst0: str) -> "VFS":
    method _copy_flags (line 539) | def _copy_flags(self, name: str) -> dict[str, Any]:
    method bubble_flags (line 554) | def bubble_flags(self) -> None:
    method _find (line 563) | def _find(self, vpath: str) -> tuple["VFS", str]:
    method can_access (line 579) | def can_access(
    method get_perms (line 591) | def get_perms(self, vpath: str, uname: str) -> str:
    method get (line 598) | def get(
    method _get_share_src (line 637) | def _get_share_src(self, vrem: str) -> tuple["VFS", str]:
    method _get_dbv (line 645) | def _get_dbv(self, vrem: str) -> tuple["VFS", str]:
    method casechk (line 653) | def casechk(self, rem: str, do_stat: bool) -> bool:
    method _canonical_null (line 679) | def _canonical_null(self, rem: str, resolve: bool = True) -> str:
    method _dcanonical_null (line 682) | def _dcanonical_null(self, rem: str) -> str:
    method _canonical (line 685) | def _canonical(self, rem: str, resolve: bool = True) -> str:
    method _dcanonical (line 693) | def _dcanonical(self, rem: str) -> str:
    method _canonical_shr (line 702) | def _canonical_shr(self, rem: str, resolve: bool = True) -> str:
    method _dcanonical_shr (line 725) | def _dcanonical_shr(self, rem: str) -> str:
    method _ls_nope (line 744) | def _ls_nope(
    method _ls_shr (line 749) | def _ls_shr(
    method _ls (line 764) | def _ls(
    method walk (line 812) | def walk(
    method zipgen (line 906) | def zipgen(
    method chk_ap (line 959) | def chk_ap(self, ap: str, st: Optional[os.stat_result] = None) -> Opti...
    method check_landmarks (line 1008) | def check_landmarks(self) -> bool:
  class AuthSrv (line 1062) | class AuthSrv(object):
    method __init__ (line 1065) | def __init__(
    method log (line 1120) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method laggy_iter (line 1124) | def laggy_iter(self, iterable: Iterable[Any]) -> Generator[Any, None, ...
    method vf0 (line 1134) | def vf0(self):
    method vf0b (line 1137) | def vf0b(self):
    method idp_checkin (line 1140) | def idp_checkin(
    method _update_idp_db (line 1171) | def _update_idp_db(self, uname: str, gname: str) -> None:
    method _map_volume_idp (line 1187) | def _map_volume_idp(
    method _map_volume (line 1276) | def _map_volume(
    method _e (line 1316) | def _e(self, desc: Optional[str] = None) -> None:
    method _l (line 1328) | def _l(self, ln: str, c: int, desc: str) -> None:
    method _all_un_gn (line 1342) | def _all_un_gn(
    method _parse_config_file (line 1366) | def _parse_config_file(
    method _parse_config_file_2 (line 1392) | def _parse_config_file_2(
    method _read_vol_str_idp (line 1586) | def _read_vol_str_idp(
    method _read_vol_str (line 1665) | def _read_vol_str(self, lvl: str, unames: list[str], axs: AXS) -> None:
    method _read_volflag (line 1701) | def _read_volflag(
    method reload (line 1759) | def reload(self, verbosity: int = 9) -> None:
    method _reload (line 1769) | def _reload(self, verbosity: int = 9) -> None:
    method setup_auth_ord (line 3307) | def setup_auth_ord(self) -> None:
    method load_idp_db (line 3319) | def load_idp_db(self, quiet=False) -> None:
    method load_sessions (line 3358) | def load_sessions(self, quiet=False) -> None:
    method forget_session (line 3404) | def forget_session(self, broker: Optional["BrokerCli"], uname: str) ->...
    method _forget_session (line 3411) | def _forget_session(self, uname: str) -> None:
    method chpw (line 3427) | def chpw(self, broker: Optional["BrokerCli"], uname, pw) -> tuple[bool...
    method setup_chpw (line 3476) | def setup_chpw(self, acct: dict[str, str]) -> None:
    method setup_pwhash (line 3534) | def setup_pwhash(self, acct: dict[str, str]) -> None:
    method chk_sqlite_threadsafe (line 3582) | def chk_sqlite_threadsafe(self) -> str:
    method dbg_ls (line 3599) | def dbg_ls(self) -> None:
    method cgen (line 3722) | def cgen(self) -> None:
  function derive_args (line 3913) | def derive_args(args: argparse.Namespace) -> None:
  function n_du_who (line 3918) | def n_du_who(s: str) -> int:
  function n_ver_who (line 3932) | def n_ver_who(s: str) -> int:
  function split_cfg_ln (line 3942) | def split_cfg_ln(ln: str) -> dict[str, Any]:
  function expand_config_file (line 3964) | def expand_config_file(
  function upgrade_cfg_fmt (line 4047) | def upgrade_cfg_fmt(

FILE: copyparty/bos/bos.py
  function chmod (line 26) | def chmod(p: str, mode: int) -> None:
  function chown (line 30) | def chown(p: str, uid: int, gid: int) -> None:
  function listdir (line 34) | def listdir(p: str = ".") -> list[str]:
  function makedirs (line 38) | def makedirs(name: str, vf: dict[str, Any] = MKD_755, exist_ok: bool = T...
  function mkdir (line 65) | def mkdir(p: str, mode: int = 0o755) -> None:
  function open (line 69) | def open(p: str, *a, **ka) -> int:
  function readlink (line 73) | def readlink(p: str) -> str:
  function rename (line 77) | def rename(src: str, dst: str) -> None:
  function replace (line 81) | def replace(src: str, dst: str) -> None:
  function rmdir (line 85) | def rmdir(p: str) -> None:
  function stat (line 89) | def stat(p: str) -> os.stat_result:
  function unlink (line 93) | def unlink(p: str) -> None:
  function utime (line 97) | def utime(
  function utime_c (line 106) | def utime_c(
  function lstat (line 146) | def lstat(p: str) -> os.stat_result:

FILE: copyparty/bos/path.py
  function abspath (line 9) | def abspath(p: str) -> str:
  function exists (line 13) | def exists(p: str) -> bool:
  function getmtime (line 17) | def getmtime(p: str, follow_symlinks: bool = True) -> float:
  function getsize (line 24) | def getsize(p: str) -> int:
  function isfile (line 28) | def isfile(p: str) -> bool:
  function isdir (line 32) | def isdir(p: str) -> bool:
  function islink (line 36) | def islink(p: str) -> bool:
  function lexists (line 40) | def lexists(p: str) -> bool:
  function realpath (line 44) | def realpath(p: str) -> str:

FILE: copyparty/broker_mp.py
  class MProcess (line 22) | class MProcess(mp.Process):
    method __init__ (line 23) | def __init__(
  class BrokerMp (line 35) | class BrokerMp(object):
    method __init__ (line 38) | def __init__(self, hub: "SvcHub") -> None:
    method shutdown (line 62) | def shutdown(self) -> None:
    method reload (line 79) | def reload(self) -> None:
    method reload_sessions (line 84) | def reload_sessions(self) -> None:
    method collector (line 88) | def collector(self, proc: MProcess) -> None:
    method ask (line 118) | def ask(self, dest: str, *args: Any) -> Union[ExceptionalQueue, NotExQ...
    method wask (line 130) | def wask(self, dest: str, *args: Any) -> list[Union[ExceptionalQueue, ...
    method say (line 143) | def say(self, dest: str, *args: Any) -> None:
    method periodic (line 167) | def periodic(self) -> None:

FILE: copyparty/broker_mpw.py
  class MpWorker (line 25) | class MpWorker(BrokerCli):
    method __init__ (line 28) | def __init__(
    method signal_handler (line 70) | def signal_handler(self, sig: Optional[int], frame: Optional[FrameType...
    method _log_enabled (line 74) | def _log_enabled(self, src: str, msg: str, c: Union[int, str] = 0) -> ...
    method _log_disabled (line 77) | def _log_disabled(self, src: str, msg: str, c: Union[int, str] = 0) ->...
    method logw (line 80) | def logw(self, msg: str, c: Union[int, str] = 0) -> None:
    method main (line 83) | def main(self) -> None:
    method ask (line 121) | def ask(self, dest: str, *args: Any) -> Union[ExceptionalQueue, NotExQ...
    method say (line 130) | def say(self, dest: str, *args: Any, retq_id=0) -> None:

FILE: copyparty/broker_thr.py
  class BrokerThr (line 19) | class BrokerThr(BrokerCli):
    method __init__ (line 22) | def __init__(self, hub: "SvcHub") -> None:
    method shutdown (line 39) | def shutdown(self) -> None:
    method noop (line 43) | def noop(self) -> None:
    method ask (line 46) | def ask(self, dest: str, *args: Any) -> Union[ExceptionalQueue, NotExQ...
    method say (line 55) | def say(self, dest: str, *args: Any) -> None:

FILE: copyparty/broker_util.py
  class ExceptionalQueue (line 21) | class ExceptionalQueue(Queue, object):
    method get (line 22) | def get(self, block: bool = True, timeout: Optional[float] = None) -> ...
  class NotExQueue (line 35) | class NotExQueue(object):
    method __init__ (line 40) | def __init__(self, rv: Any) -> None:
    method get (line 43) | def get(self) -> Any:
  class BrokerCli (line 47) | class BrokerCli(object):
    method __init__ (line 59) | def __init__(self) -> None:
    method ask (line 62) | def ask(self, dest: str, *args: Any) -> Union[ExceptionalQueue, NotExQ...
    method say (line 65) | def say(self, dest: str, *args: Any) -> None:
  function try_exec (line 69) | def try_exec(want_retval: Union[bool, int], func: Any, *args: list[Any])...

FILE: copyparty/cert.py
  function _sp_err (line 23) | def _sp_err(exe, what, rc, so, se, sin):
  function ensure_cert (line 36) | def ensure_cert(log: "RootLogger", args) -> None:
  function _read_crt (line 79) | def _read_crt(args, fn):
  function _gen_ca (line 101) | def _gen_ca(log: "RootLogger", args):
  function _gen_srv (line 143) | def _gen_srv(log: "RootLogger", args, netdevs: dict[str, Netdev]):
  function gencert (line 249) | def gencert(log: "RootLogger", args, netdevs: dict[str, Netdev]):

FILE: copyparty/cfg.py
  function vf_bmap (line 12) | def vf_bmap() -> dict[str, str]:
  function vf_vmap (line 85) | def vf_vmap() -> dict[str, str]:
  function vf_cmap (line 170) | def vf_cmap() -> dict[str, str]:

FILE: copyparty/dxml.py
  class BadXML (line 14) | class BadXML(Exception):
  function get_ET (line 18) | def get_ET() -> ET.XMLParser:
  class _DXMLParser (line 44) | class _DXMLParser(XMLParser):  # type: ignore
    method __init__ (line 45) | def __init__(self) -> None:
    method nope (line 55) | def nope(self, *a: Any, **ka: Any) -> None:
  class _NG (line 59) | class _NG(XMLParser):  # type: ignore
    method __int__ (line 60) | def __int__(self) -> None:
  function parse_xml (line 67) | def parse_xml(txt: str) -> ET.Element:
  function selftest (line 76) | def selftest() -> bool:
  function mktnod (line 110) | def mktnod(name: str, text: str) -> ET.Element:
  function mkenod (line 116) | def mkenod(name: str, sub_el: Optional[ET.Element] = None) -> ET.Element:

FILE: copyparty/fsutil.py
  class Fstab (line 21) | class Fstab(object):
    method __init__ (line 22) | def __init__(self, log: "RootLogger", args: argparse.Namespace, verbos...
    method log (line 35) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method get (line 40) | def get(self, path: str) -> tuple[str, str]:
    method _winpath (line 76) | def _winpath(self, path: str) -> str:
    method build_fallback (line 85) | def build_fallback(self) -> None:
    method _from_sp_mount (line 89) | def _from_sp_mount(self) -> dict[str, str]:
    method _from_proc (line 107) | def _from_proc(self) -> dict[str, str]:
    method build_tab (line 119) | def build_tab(self) -> None:
    method relabel (line 160) | def relabel(self, path: str, nval: str) -> None:
    method get_unix (line 187) | def get_unix(self, path: str) -> tuple[str, str]:
    method get_w32 (line 207) | def get_w32(self, path: str) -> tuple[str, str]:
  function ramdisk_chk (line 221) | def ramdisk_chk(asrv: AuthSrv) -> None:

FILE: copyparty/ftpd.py
  class FSE (line 49) | class FSE(FilesystemError):
    method __init__ (line 50) | def __init__(self, msg: str, severity: int = 0) -> None:
  class FtpAuth (line 55) | class FtpAuth(DummyAuthorizer):
    method __init__ (line 56) | def __init__(self, hub: "SvcHub") -> None:
    method validate_authentication (line 60) | def validate_authentication(
    method get_home_dir (line 121) | def get_home_dir(self, username: str) -> str:
    method has_user (line 124) | def has_user(self, username: str) -> bool:
    method has_perm (line 128) | def has_perm(self, username: str, perm: int, path: Optional[str] = Non...
    method get_perms (line 131) | def get_perms(self, username: str) -> str:
    method get_msg_login (line 134) | def get_msg_login(self, username: str) -> str:
    method get_msg_quit (line 137) | def get_msg_quit(self, username: str) -> str:
  class FtpFs (line 141) | class FtpFs(AbstractedFS):
    method __init__ (line 142) | def __init__(
    method log (line 157) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method v2a (line 160) | def v2a(
    method rv2a (line 213) | def rv2a(
    method ftp2fs (line 223) | def ftp2fs(self, ftppath: str) -> str:
    method fs2ftp (line 227) | def fs2ftp(self, fspath: str) -> str:
    method validpath (line 231) | def validpath(self, path: str) -> bool:
    method open (line 238) | def open(self, filename: str, mode: str) -> typing.IO[Any]:
    method chdir (line 309) | def chdir(self, path: str) -> None:
    method mkdir (line 331) | def mkdir(self, path: str) -> None:
    method listdir (line 335) | def listdir(self, path: str) -> list[str]:
    method rmdir (line 381) | def rmdir(self, path: str) -> None:
    method remove (line 389) | def remove(self, path: str) -> None:
    method rename (line 399) | def rename(self, src: str, dst: str) -> None:
    method chmod (line 410) | def chmod(self, path: str, mode: str) -> None:
    method stat (line 413) | def stat(self, path: str) -> os.stat_result:
    method utime (line 428) | def utime(self, path: str, timeval: float) -> None:
    method lstat (line 432) | def lstat(self, path: str) -> os.stat_result:
    method isfile (line 436) | def isfile(self, path: str) -> bool:
    method islink (line 446) | def islink(self, path: str) -> bool:
    method isdir (line 450) | def isdir(self, path: str) -> bool:
    method getsize (line 460) | def getsize(self, path: str) -> int:
    method getmtime (line 464) | def getmtime(self, path: str) -> float:
    method realpath (line 468) | def realpath(self, path: str) -> str:
    method lexists (line 471) | def lexists(self, path: str) -> bool:
    method get_user_by_uid (line 475) | def get_user_by_uid(self, uid: int) -> str:
    method get_group_by_uid (line 478) | def get_group_by_uid(self, gid: int) -> str:
  class FtpHandler (line 482) | class FtpHandler(FTPHandler):
    method __init__ (line 488) | def __init__(self, conn: Any, server: Any, ioloop: Any = None) -> None:
    method ftp_STOR (line 516) | def ftp_STOR(self, file: str, mode: str = "w") -> Any:
    method log_transfer (line 556) | def log_transfer(
  class SftpHandler (line 592) | class SftpHandler(FtpHandler, TLS_FTPHandler):
  class Ftpd (line 599) | class Ftpd(object):
    method __init__ (line 600) | def __init__(self, hub: "SvcHub") -> None:
  function join (line 672) | def join(p1: str, p2: str) -> str:

FILE: copyparty/httpcli.py
  function _build_zip_xcode (line 195) | def _build_zip_xcode() -> Sequence[str]:
  function _arg2cfg (line 207) | def _arg2cfg(txt: str) -> str:
  class HttpCli (line 211) | class HttpCli(object):
    method __init__ (line 216) | def __init__(self, conn: "HttpConn") -> None:
    method log (line 284) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method unpwd (line 294) | def unpwd(self, m: Match[str]) -> str:
    method _assert_safe_rem (line 299) | def _assert_safe_rem(self, rem: str) -> None:
    method _gen_fk (line 305) | def _gen_fk(self, alg: int, salt: str, fspath: str, fsize: int, inode:...
    method j2s (line 310) | def j2s(self, name: str, **ka: Any) -> str:
    method j2j (line 331) | def j2j(self, name: str) -> jinja2.Template:
    method run (line 334) | def run(self) -> bool:
    method dip (line 960) | def dip(self) -> str:
    method cbonk (line 966) | def cbonk(self, g: Garda, v: str, reason: str, descr: str) -> bool:
    method is_banned (line 1012) | def is_banned(self) -> bool:
    method permit_caching (line 1031) | def permit_caching(self) -> None:
    method k304 (line 1040) | def k304(self) -> bool:
    method no304 (line 1044) | def no304(self) -> bool:
    method _build_html_head (line 1048) | def _build_html_head(self, kv: dict[str, Any]) -> None:
    method send_headers (line 1071) | def send_headers(
    method reply (line 1139) | def reply(
    method loud_reply (line 1200) | def loud_reply(self, body: str, *args: Any, **kwargs: Any) -> None:
    method terse_reply (line 1207) | def terse_reply(self, body: bytes, status: int = 200) -> None:
    method urlq (line 1224) | def urlq(self, add: dict[str, str], rm: list[str]) -> str:
    method ourlq (line 1249) | def ourlq(self) -> str:
    method redirect (line 1265) | def redirect(
    method _cors (line 1292) | def _cors(self) -> bool:
    method handle_get (line 1356) | def handle_get(self) -> bool:
    method tx_rss (line 1528) | def tx_rss(self) -> bool:
    method tx_zls (line 1685) | def tx_zls(self, abspath) -> bool:
    method tx_zget (line 1702) | def tx_zget(self, abspath) -> bool:
    method handle_propfind (line 1746) | def handle_propfind(self) -> bool:
    method handle_proppatch (line 1992) | def handle_proppatch(self) -> bool:
    method handle_lock (line 2051) | def handle_lock(self) -> bool:
    method handle_unlock (line 2120) | def handle_unlock(self) -> bool:
    method handle_mkcol (line 2136) | def handle_mkcol(self) -> bool:
    method handle_cpmv (line 2160) | def handle_cpmv(self) -> bool:
    method _applesan (line 2191) | def _applesan(self) -> bool:
    method send_chunk (line 2204) | def send_chunk(self, txt: str, enc: str, bmax: int) -> str:
    method handle_options (line 2220) | def handle_options(self) -> bool:
    method handle_delete (line 2238) | def handle_delete(self) -> bool:
    method handle_put (line 2244) | def handle_put(self) -> bool:
    method handle_post (line 2264) | def handle_post(self) -> bool:
    method handle_smsg (line 2379) | def handle_smsg(self) -> bool:
    method get_xml_enc (line 2410) | def get_xml_enc(self, txt: str) -> str:
    method get_body_reader (line 2425) | def get_body_reader(self) -> tuple[Generator[bytes, None, None], int]:
    method dump_to_file (line 2439) | def dump_to_file(self, is_put: bool) -> tuple[int, str, str, str, int,...
    method handle_stash (line 2797) | def handle_stash(self, is_put: bool) -> bool:
    method bakflip (line 2831) | def bakflip(
    method _spd (line 2884) | def _spd(self, nbytes: int, add: bool = True) -> str:
    method handle_post_multipart (line 2892) | def handle_post_multipart(self) -> bool:
    method handle_zip_post (line 2934) | def handle_zip_post(self) -> bool:
    method handle_post_json (line 2959) | def handle_post_json(self) -> bool:
    method handle_search (line 3076) | def handle_search(self, body: dict[str, Any]) -> bool:
    method handle_post_binary (line 3140) | def handle_post_binary(self) -> bool:
    method handle_chpw (line 3357) | def handle_chpw(self) -> bool:
    method handle_login (line 3379) | def handle_login(self) -> bool:
    method handle_logout (line 3420) | def handle_logout(self) -> bool:
    method get_pwd_cookie (line 3435) | def get_pwd_cookie(self, pwd: str) -> tuple[bool, str]:
    method set_idp_cookie (line 3488) | def set_idp_cookie(self, ases) -> None:
    method handle_mkdir (line 3501) | def handle_mkdir(self) -> bool:
    method _mkdir (line 3508) | def _mkdir(self, vpath: str, dav: bool = False) -> bool:
    method handle_new_md (line 3547) | def handle_new_md(self) -> bool:
    method upload_flags (line 3621) | def upload_flags(self, vfs: VFS) -> tuple[int, int, list[str], list[st...
    method handle_plain_upload (line 3643) | def handle_plain_upload(
    method handle_text_upload (line 4052) | def handle_text_upload(self) -> bool:
    method _chk_lastmod (line 4265) | def _chk_lastmod(self, file_ts: int) -> tuple[str, bool, bool]:
    method _use_dirkey (line 4289) | def _use_dirkey(self, vn: VFS, ap: str) -> bool:
    method _use_filekey (line 4315) | def _use_filekey(self, vn: VFS, ap: str, st: os.stat_result) -> bool:
    method _add_logues (line 4343) | def _add_logues(
    method _expand (line 4380) | def _expand(self, txt: str, phs: list[str]) -> str:
    method _can_tail (line 4404) | def _can_tail(self, volflags: dict[str, Any]) -> bool:
    method _can_zip (line 4418) | def _can_zip(self, volflags: dict[str, Any]) -> str:
    method tx_res (line 4431) | def tx_res(self, req_path: str) -> bool:
    method tx_file (line 4567) | def tx_file(self, oh_k: str, req_path: str, ptop: Optional[str] = None...
    method tx_tail (line 4838) | def tx_tail(
    method tx_pipe (line 4972) | def tx_pipe(
    method tx_zip (line 5125) | def tx_zip(
    method tx_ico (line 5260) | def tx_ico(self, ext: str, exact: bool = False) -> bool:
    method tx_svg (line 5284) | def tx_svg(self, txt: str, small: bool = False) -> bool:
    method tx_qr (line 5294) | def tx_qr(self):
    method tx_md (line 5321) | def tx_md(self, vn: VFS, fs_path: str) -> bool:
    method tx_svcs (line 5436) | def tx_svcs(self) -> bool:
    method tx_mounts (line 5489) | def tx_mounts(self) -> bool:
    method setck (line 5659) | def setck(self) -> bool:
    method set_cfg_reset (line 5673) | def set_cfg_reset(self) -> bool:
    method tx_404 (line 5683) | def tx_404(self, is_403: bool = False) -> bool:
    method on40x (line 5734) | def on40x(self, mods: list[str], vn: VFS, rem: str) -> str:
    method scanvol (line 5748) | def scanvol(self) -> bool:
    method handle_reload (line 5776) | def handle_reload(self) -> bool:
    method tx_stack (line 5790) | def tx_stack(self) -> bool:
    method tx_tree (line 5808) | def tx_tree(self) -> bool:
    method gen_tree (line 5834) | def gen_tree(self, top: str, target: str, dk: str) -> dict[str, Any]:
    method get_dls (line 5908) | def get_dls(self) -> list[list[Any]]:
    method tx_dls (line 5936) | def tx_dls(self) -> bool:
    method tx_ups (line 5953) | def tx_ups(self) -> bool:
    method tx_rups (line 6120) | def tx_rups(self) -> bool:
    method tx_idp (line 6259) | def tx_idp(self) -> bool:
    method tx_shares (line 6285) | def tx_shares(self) -> bool:
    method handle_eshare (line 6333) | def handle_eshare(self) -> bool:
    method handle_share (line 6383) | def handle_share(self, req: dict[str, str]) -> bool:
    method handle_rm (line 6505) | def handle_rm(self, req: list[str]) -> bool:
    method handle_mv (line 6536) | def handle_mv(self) -> bool:
    method _mv (line 6548) | def _mv(self, vsrc: str, vdst: str, overwrite: bool) -> bool:
    method handle_cp (line 6569) | def handle_cp(self) -> bool:
    method _cp (line 6581) | def _cp(self, vsrc: str, vdst: str, overwrite: bool) -> bool:
    method handle_fs_abrt (line 6601) | def handle_fs_abrt(self):
    method tx_ls_vols (line 6610) | def tx_ls_vols(self) -> bool:
    method tx_ls (line 6653) | def tx_ls(self, ls: dict[str, Any]) -> bool:
    method tx_browser (line 6725) | def tx_browser(self) -> bool:

FILE: copyparty/httpconn.py
  class HttpConn (line 41) | class HttpConn(object):
    method __init__ (line 47) | def __init__(
    method shutdown (line 89) | def shutdown(self) -> None:
    method set_rproxy (line 96) | def set_rproxy(self, ip: Optional[str] = None) -> str:
    method log (line 109) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method get_u2idx (line 112) | def get_u2idx(self) -> Optional[U2idx]:
    method _detect_https (line 121) | def _detect_https(self) -> bool:
    method run (line 149) | def run(self) -> None:

FILE: copyparty/httpsrv.py
  function load_jinja2_resource (line 99) | def load_jinja2_resource(E: EnvParams, name: str):
  class HttpSrv (line 104) | class HttpSrv(object):
    method __init__ (line 110) | def __init__(self, broker: "BrokerCli", nid: Optional[int]) -> None:
    method post_init (line 236) | def post_init(self) -> None:
    method set_bad_ver (line 243) | def set_bad_ver(self) -> None:
    method set_netdevs (line 246) | def set_netdevs(self, netdevs: dict[str, Netdev]) -> None:
    method start_threads (line 253) | def start_threads(self, n: int) -> None:
    method stop_threads (line 261) | def stop_threads(self, n: int) -> None:
    method periodic (line 270) | def periodic(self) -> None:
    method listen (line 284) | def listen(self, sck: socket.socket, nlisteners: int) -> None:
    method thr_listen (line 312) | def thr_listen(self, srv_sck: socket.socket) -> None:
    method accept (line 437) | def accept(self, sck: socket.socket, addr: tuple[str, int]) -> None:
    method thr_poolw (line 475) | def thr_poolw(self) -> None:
    method shutdown (line 497) | def shutdown(self) -> None:
    method thr_client (line 524) | def thr_client(self, sck: socket.socket, addr: tuple[str, int]) -> None:
    method cachebuster (line 571) | def cachebuster(self) -> str:
    method get_u2idx (line 593) | def get_u2idx(self, ident: str) -> Optional[U2idx]:
    method put_u2idx (line 614) | def put_u2idx(self, ident: str, u2idx: U2idx) -> None:
    method read_dls (line 621) | def read_dls(
    method write_dls (line 633) | def write_dls(

FILE: copyparty/ico.py
  class Ico (line 14) | class Ico(object):
    method __init__ (line 15) | def __init__(self, args: argparse.Namespace) -> None:
    method get (line 18) | def get(self, ext: str, as_thumb: bool, chrome: bool) -> tuple[str, by...

FILE: copyparty/mdns.py
  class MDNS_Sck (line 79) | class MDNS_Sck(MC_Sck):
    method __init__ (line 80) | def __init__(
  class MDNS (line 99) | class MDNS(MCast):
    method __init__ (line 100) | def __init__(self, hub: "SvcHub", ngen: int) -> None:
    method log (line 135) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method build_svcs (line 138) | def build_svcs(self) -> tuple[dict[str, dict[str, Any]], set[str]]:
    method build_replies (line 197) | def build_replies(self) -> None:
    method send_probes (line 284) | def send_probes(self) -> None:
    method run (line 310) | def run(self) -> None:
    method run2 (line 338) | def run2(self) -> None:
    method stop (line 402) | def stop(self, panic=False) -> None:
    method eat (line 415) | def eat(self, buf: bytes, addr: tuple[str, int], sck: socket.socket) -...
    method process (line 578) | def process(self) -> None:
    method _tx (line 609) | def _tx(self, srv: MDNS_Sck, msg: bytes, cooldown: float) -> bool:

FILE: copyparty/metrics.py
  class Metrics (line 15) | class Metrics(object):
    method __init__ (line 16) | def __init__(self, hsrv: "HttpSrv") -> None:
    method tx (line 19) | def tx(self, cli: "HttpCli") -> bool:

FILE: copyparty/mtag.py
  function have_ff (line 48) | def have_ff(scmd: str) -> bool:
  class MParser (line 74) | class MParser(object):
    method __init__ (line 75) | def __init__(self, cmdline: str) -> None:
  function au_unpk (line 133) | def au_unpk(
  function ffprobe (line 216) | def ffprobe(
  function parse_ffprobe (line 232) | def parse_ffprobe(
  function get_cover_from_epub (line 387) | def get_cover_from_epub(log: "NamedLogger", abspath: str) -> Optional[IO...
  function _get_cover_from_epub2 (line 444) | def _get_cover_from_epub2(
  class MTag (line 463) | class MTag(object):
    method __init__ (line 464) | def __init__(self, log_func: "RootLogger", args: argparse.Namespace) -...
    method log (line 581) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method normalize_tags (line 584) | def normalize_tags(
    method compare (line 623) | def compare(self, abspath: str) -> dict[str, Union[str, float]]:
    method _get_xattr (line 661) | def _get_xattr(
    method _get_main (line 688) | def _get_main(
    method get_mutagen (line 704) | def get_mutagen(self, abspath: str) -> dict[str, Union[str, float]]:
    method get_ffprobe (line 766) | def get_ffprobe(self, abspath: str) -> dict[str, Union[str, float]]:
    method get_bin (line 779) | def get_bin(

FILE: copyparty/multicast.py
  class NoIPs (line 30) | class NoIPs(Exception):
  class MC_Sck (line 34) | class MC_Sck(object):
    method __init__ (line 37) | def __init__(
  class MCast (line 58) | class MCast(object):
    method __init__ (line 59) | def __init__(
    method log (line 93) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method create_servers (line 96) | def create_servers(self) -> list[str]:
    method setup_socket (line 235) | def setup_socket(self, srv: MC_Sck) -> None:
    method hop (line 312) | def hop(self, srv: MC_Sck, on: bool) -> bool:
    method hopper (line 339) | def hopper(self):
    method map_client (line 356) | def map_client(self, cip: str) -> Optional[MC_Sck]:

FILE: copyparty/pwhash.py
  class PWHash (line 23) | class PWHash(object):
    method __init__ (line 24) | def __init__(self, args: argparse.Namespace):
    method _cache_hash (line 56) | def _cache_hash(self, plain: str) -> str:
    method _gen_sha2 (line 76) | def _gen_sha2(self, plain: str) -> str:
    method _gen_scrypt (line 85) | def _gen_scrypt(self, plain: str) -> str:
    method _gen_argon2 (line 110) | def _gen_argon2(self, plain: str) -> str:
    method stdin (line 141) | def stdin(self) -> None:
    method cli (line 148) | def cli(self) -> None:

FILE: copyparty/qrkode.py
  function _qrgen (line 29) | def _qrgen(data: Union[bytes, Sequence[int]]) -> "QrCode":
  function qr2txt (line 43) | def qr2txt(qr: QrCode, zoom: int = 1, pad: int = 4) -> str:
  function qr2png (line 71) | def qr2png(
  function qr2svg (line 98) | def qr2svg(qr: QrCode, border: int) -> str:

FILE: copyparty/sftpd.py
  class SSH_Srv (line 54) | class SSH_Srv(paramiko.ServerInterface):
    method __init__ (line 55) | def __init__(self, hub: "SvcHub", addr: Any):
    method log (line 75) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method get_allowed_auths (line 78) | def get_allowed_auths(self, username: str) -> str:
    method get_banner (line 81) | def get_banner(self) -> tuple[Optional[str], Optional[str]]:
    method check_channel_request (line 93) | def check_channel_request(self, kind: str, chanid: int) -> int:
    method check_auth_none (line 100) | def check_auth_none(self, username: str) -> int:
    method _check_auth_none (line 107) | def _check_auth_none(self, uname: str) -> int:
    method check_auth_password (line 127) | def check_auth_password(self, username: str, password: str) -> int:
    method _check_auth_password (line 134) | def _check_auth_password(self, uname: str, pw: str) -> int:
    method check_auth_publickey (line 205) | def check_auth_publickey(self, username: str, key: paramiko.PKey) -> int:
    method _check_auth_publickey (line 212) | def _check_auth_publickey(self, uname: str, key: paramiko.PKey) -> int:
  class SFTP_FH (line 253) | class SFTP_FH(paramiko.SFTPHandle):
    method __init__ (line 254) | def __init__(self, flags: int = 0) -> None:
    method stat (line 260) | def stat(self):
    method chattr (line 267) | def chattr(self, attr):
  class SFTP_Srv (line 279) | class SFTP_Srv(paramiko.SFTPServerInterface):
    method __init__ (line 280) | def __init__(self, ssh: paramiko.ServerInterface, *a, **ka):
    method log (line 308) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method v2a (line 311) | def v2a(
    method list_folder (line 360) | def list_folder(self, path: str) -> list[SATTR] | int:
    method _list_folder (line 372) | def _list_folder(self, path: str) -> list[SATTR] | int:
    method stat (line 423) | def stat(self, path: str) -> SATTR | int:
    method lstat (line 430) | def lstat(self, path: str) -> SATTR | int:
    method _stat (line 437) | def _stat(self, vp: str) -> SATTR | int:
    method open (line 459) | def open(self, path: str, flags: int, attr: SATTR) -> paramiko.SFTPHan...
    method _open (line 466) | def _open(self, vp: str, iflag: int, attr: SATTR) -> paramiko.SFTPHand...
    method remove (line 586) | def remove(self, path: str) -> int:
    method _remove (line 593) | def _remove(self, vp: str) -> int:
    method rename (line 627) | def rename(self, oldpath: str, newpath: str) -> int:
    method _rename (line 634) | def _rename(self, svp: str, dvp: str) -> int:
    method mkdir (line 651) | def mkdir(self, path: str, attr: SATTR) -> int:
    method _mkdir (line 658) | def _mkdir(self, vp: str, attr: SATTR) -> int:
    method rmdir (line 675) | def rmdir(self, path: str) -> int:
    method _rmdir (line 682) | def _rmdir(self, vp: str) -> int:
    method chattr (line 697) | def chattr(self, path: str, attr: SATTR) -> int:
    method _chattr (line 704) | def _chattr(self, vp: str, attr: SATTR) -> int:
    method symlink (line 719) | def symlink(self, target_path: str, path: str) -> int:
    method readlink (line 722) | def readlink(self, path: str) -> str | int:
    method canonicalize (line 725) | def canonicalize(self, path: str) -> str:
  class Sftpd (line 729) | class Sftpd(object):
    method __init__ (line 730) | def __init__(self, hub: "SvcHub") -> None:
    method log (line 786) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method _bind (line 789) | def _bind(self, ip: str) -> None:
    method _accept (line 817) | def _accept(self, srv: socket.socket) -> None:
    method _accept2 (line 825) | def _accept2(self, cli, addr) -> None:
    method run (line 848) | def run(self):
    method _run_select (line 858) | def _run_select(self):
    method _run_poll (line 864) | def _run_poll(self):

FILE: copyparty/smbd.py
  class SMB (line 28) | class SMB(object):
    method __init__ (line 29) | def __init__(self, hub: "SvcHub") -> None:
    method nlog (line 126) | def nlog(self, msg: str, c: Union[int, str] = 0) -> None:
    method start (line 129) | def start(self) -> None:
    method _auth_cb (line 132) | def _auth_cb(self, *a, **ka):
    method _uname (line 151) | def _uname(self) -> str:
    method _v2a (line 178) | def _v2a(
    method _listdir (line 196) | def _listdir(self, vpath: str, *a: Any, **ka: Any) -> list[str]:
    method _open (line 229) | def _open(
    method _close (line 288) | def _close(self, fd: int) -> None:
    method _rename (line 308) | def _rename(self, vp1: str, vp2: str) -> None:
    method _mkdir (line 332) | def _mkdir(self, vpath: str) -> None:
    method _stat (line 344) | def _stat(self, vpath: str, *a: Any, **ka: Any) -> os.stat_result:
    method _unlink (line 356) | def _unlink(self, vpath: str) -> None:
    method _utime (line 371) | def _utime(self, vpath: str, times: tuple[float, float]) -> None:
    method _p_exists (line 383) | def _p_exists(self, vpath: str) -> bool:
    method _p_getsize (line 394) | def _p_getsize(self, vpath: str) -> int:
    method _p_isdir (line 398) | def _p_isdir(self, vpath: str) -> bool:
    method _p_join (line 407) | def _p_join(self, *a) -> str:
    method _hook (line 413) | def _hook(self, *a: Any, **ka: Any) -> None:
    method _disarm (line 418) | def _disarm(self) -> None:
    method _is_in_file_jail (line 444) | def _is_in_file_jail(self, *a: Any) -> bool:
  function yeet (line 449) | def yeet(msg: str) -> None:

FILE: copyparty/ssdp.py
  class SSDP_Sck (line 26) | class SSDP_Sck(MC_Sck):
    method __init__ (line 27) | def __init__(self, *a):
  class SSDPr (line 32) | class SSDPr(object):
    method __init__ (line 35) | def __init__(self, broker: "BrokerCli") -> None:
    method reply (line 39) | def reply(self, hc: "HttpCli") -> bool:
    method tx_device (line 46) | def tx_device(self, hc: "HttpCli") -> bool:
  class SSDPd (line 90) | class SSDPd(MCast):
    method __init__ (line 93) | def __init__(self, hub: "SvcHub", ngen: int) -> None:
    method log (line 107) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method run (line 110) | def run(self) -> None:
    method run2 (line 143) | def run2(self) -> None:
    method stop (line 183) | def stop(self) -> None:
    method eat (line 193) | def eat(self, buf: bytes, addr: tuple[str, int]) -> None:

FILE: copyparty/star.py
  class QFile (line 21) | class QFile(object):  # inherit io.StringIO for painful typing
    method __init__ (line 24) | def __init__(self) -> None:
    method write (line 29) | def write(self, buf: Optional[bytes]) -> None:
  class StreamTar (line 42) | class StreamTar(StreamArc):
    method __init__ (line 45) | def __init__(
    method gen (line 93) | def gen(self) -> Generator[Optional[bytes], None, None]:
    method ser (line 115) | def ser(self, f: dict[str, Any]) -> None:
    method _gen (line 134) | def _gen(self) -> None:

FILE: copyparty/stolen/dnslib/bimap.py
  class BimapError (line 6) | class BimapError(Exception):
  class Bimap (line 10) | class Bimap(object):
    method __init__ (line 11) | def __init__(self, name, forward, error=AttributeError):
    method get (line 17) | def get(self, k, default=None):
    method __getitem__ (line 23) | def __getitem__(self, k):
    method __getattr__ (line 32) | def __getattr__(self, k):

FILE: copyparty/stolen/dnslib/bit.py
  function get_bits (line 6) | def get_bits(data, offset, bits=1):
  function set_bits (line 11) | def set_bits(data, value, offset, bits=1):

FILE: copyparty/stolen/dnslib/buffer.py
  class BufferError (line 7) | class BufferError(Exception):
  class Buffer (line 11) | class Buffer(object):
    method __init__ (line 12) | def __init__(self, data=b""):
    method remaining (line 16) | def remaining(self):
    method get (line 19) | def get(self, length):
    method hex (line 30) | def hex(self):
    method pack (line 33) | def pack(self, fmt, *args):
    method append (line 37) | def append(self, s):
    method update (line 41) | def update(self, ptr, fmt, *args):
    method unpack (line 45) | def unpack(self, fmt):
    method __len__ (line 55) | def __len__(self):

FILE: copyparty/stolen/dnslib/dns.py
  class DNSError (line 21) | class DNSError(Exception):
  function unknown_qtype (line 25) | def unknown_qtype(name, key, forward):
  function label (line 73) | def label(label, origin=None):
  class DNSRecord (line 80) | class DNSRecord(object):
    method parse (line 82) | def parse(cls, packet) -> "DNSRecord":
    method question (line 105) | def question(cls, qname, qtype="A", qclass="IN"):
    method __init__ (line 110) | def __init__(
    method reply (line 125) | def reply(self, ra=1, aa=1):
    method add_question (line 131) | def add_question(self, *q) -> None:
    method add_answer (line 135) | def add_answer(self, *rr) -> None:
    method add_auth (line 139) | def add_auth(self, *auth) -> None:
    method add_ar (line 143) | def add_ar(self, *ar) -> None:
    method set_header_qa (line 147) | def set_header_qa(self) -> None:
    method get_q (line 153) | def get_q(self):
    method get_a (line 158) | def get_a(self):
    method pack (line 163) | def pack(self) -> bytes:
    method truncate (line 177) | def truncate(self):
    method format (line 180) | def format(self, prefix="", sort=False):
    method __repr__ (line 191) | def __repr__(self):
  class DNSHeader (line 197) | class DNSHeader(object):
    method parse (line 206) | def parse(cls, buffer):
    method __init__ (line 215) | def __init__(self, id=None, bitmap=None, q=0, a=0, auth=0, ar=0, **arg...
    method get_qr (line 247) | def get_qr(self):
    method set_qr (line 250) | def set_qr(self, val):
    method get_opcode (line 255) | def get_opcode(self):
    method set_opcode (line 258) | def set_opcode(self, val):
    method get_aa (line 263) | def get_aa(self):
    method set_aa (line 266) | def set_aa(self, val):
    method get_tc (line 271) | def get_tc(self):
    method set_tc (line 274) | def set_tc(self, val):
    method get_rd (line 279) | def get_rd(self):
    method set_rd (line 282) | def set_rd(self, val):
    method get_ra (line 287) | def get_ra(self):
    method set_ra (line 290) | def set_ra(self, val):
    method get_z (line 295) | def get_z(self):
    method set_z (line 298) | def set_z(self, val):
    method get_ad (line 303) | def get_ad(self):
    method set_ad (line 306) | def set_ad(self, val):
    method get_cd (line 311) | def get_cd(self):
    method set_cd (line 314) | def set_cd(self, val):
    method get_rcode (line 319) | def get_rcode(self):
    method set_rcode (line 322) | def set_rcode(self, val):
    method pack (line 327) | def pack(self, buffer):
    method __repr__ (line 330) | def __repr__(self):
  class DNSQuestion (line 373) | class DNSQuestion(object):
    method parse (line 375) | def parse(cls, buffer):
    method __init__ (line 385) | def __init__(self, qname=None, qtype=1, qclass=1) -> None:
    method set_qname (line 390) | def set_qname(self, qname):
    method get_qname (line 396) | def get_qname(self):
    method pack (line 401) | def pack(self, buffer):
    method __repr__ (line 405) | def __repr__(self):
  class RR (line 415) | class RR(object):
    method parse (line 422) | def parse(cls, buffer):
    method __init__ (line 434) | def __init__(self, rname=None, rtype=1, rclass=1, ttl=0, rdata=None) -...
    method set_rname (line 441) | def set_rname(self, rname):
    method get_rname (line 447) | def get_rname(self):
    method pack (line 452) | def pack(self, buffer):
    method __repr__ (line 462) | def __repr__(self):
  class RD (line 474) | class RD(object):
    method parse (line 476) | def parse(cls, buffer, length):
    method __init__ (line 483) | def __init__(self, data=b"") -> None:
    method pack (line 487) | def pack(self, buffer):
    method __repr__ (line 490) | def __repr__(self):
  function _force_bytes (line 502) | def _force_bytes(x):
  class TXT (line 509) | class TXT(RD):
    method parse (line 511) | def parse(cls, buffer, length):
    method __init__ (line 530) | def __init__(self, data) -> None:
    method pack (line 538) | def pack(self, buffer):
    method __repr__ (line 545) | def __repr__(self):
  class A (line 549) | class A(RD):
    method parse (line 554) | def parse(cls, buffer, length):
    method __init__ (line 561) | def __init__(self, data) -> None:
    method pack (line 567) | def pack(self, buffer):
    method __repr__ (line 570) | def __repr__(self):
  function _parse_ipv6 (line 574) | def _parse_ipv6(a):
  function _format_ipv6 (line 582) | def _format_ipv6(a):
  class AAAA (line 607) | class AAAA(RD):
    method parse (line 611) | def parse(cls, buffer, length):
    method __init__ (line 618) | def __init__(self, data) -> None:
    method pack (line 624) | def pack(self, buffer):
    method __repr__ (line 627) | def __repr__(self):
  class CNAME (line 631) | class CNAME(RD):
    method parse (line 633) | def parse(cls, buffer, length):
    method __init__ (line 640) | def __init__(self, label=None) -> None:
    method set_label (line 643) | def set_label(self, label):
    method get_label (line 649) | def get_label(self):
    method pack (line 654) | def pack(self, buffer):
    method __repr__ (line 657) | def __repr__(self):
  class PTR (line 663) | class PTR(CNAME):
  class SRV (line 667) | class SRV(RD):
    method parse (line 673) | def parse(cls, buffer, length):
    method __init__ (line 681) | def __init__(self, priority=0, weight=0, port=0, target=None) -> None:
    method set_target (line 687) | def set_target(self, target):
    method get_target (line 693) | def get_target(self):
    method pack (line 698) | def pack(self, buffer):
    method __repr__ (line 702) | def __repr__(self):
  function decode_type_bitmap (line 708) | def decode_type_bitmap(type_bitmap):
  function encode_type_bitmap (line 722) | def encode_type_bitmap(rrlist):
  class NSEC (line 745) | class NSEC(RD):
    method parse (line 747) | def parse(cls, buffer, length):
    method __init__ (line 756) | def __init__(self, label, rrlist) -> None:
    method set_label (line 760) | def set_label(self, label):
    method get_label (line 766) | def get_label(self):
    method pack (line 771) | def pack(self, buffer):
    method __repr__ (line 775) | def __repr__(self):

FILE: copyparty/stolen/dnslib/label.py
  function set_avahi_379 (line 17) | def set_avahi_379():
  function log_avahi_379 (line 22) | def log_avahi_379(args):
  class DNSLabelError (line 31) | class DNSLabelError(Exception):
  class DNSLabel (line 35) | class DNSLabel(object):
    method __init__ (line 36) | def __init__(self, label):
    method add (line 55) | def add(self, name):
    method idna (line 61) | def idna(self):
    method _decode (line 64) | def _decode(self, s):
    method __str__ (line 72) | def __str__(self):
    method __repr__ (line 75) | def __repr__(self):
    method __hash__ (line 78) | def __hash__(self):
    method __ne__ (line 81) | def __ne__(self, other):
    method __eq__ (line 84) | def __eq__(self, other):
    method __len__ (line 90) | def __len__(self):
  class DNSBuffer (line 94) | class DNSBuffer(Buffer):
    method __init__ (line 95) | def __init__(self, data=b""):
    method decode_name (line 99) | def decode_name(self, last=-1):
    method encode_name (line 140) | def encode_name(self, name):
    method encode_name_nocompress (line 162) | def encode_name_nocompress(self, name):

FILE: copyparty/stolen/dnslib/lex.py
  class Lexer (line 13) | class Lexer(object):
    method __init__ (line 18) | def __init__(self, f, debug=False):
    method __iter__ (line 33) | def __iter__(self):
    method next_token (line 36) | def next_token(self):
    method parse (line 42) | def parse(self):
    method read (line 48) | def read(self, n=1):
    method peek (line 60) | def peek(self, n=1):
    method pushback (line 75) | def pushback(self, s):
    method readescaped (line 80) | def readescaped(self):
    method lexStart (line 104) | def lexStart(self):

FILE: copyparty/stolen/dnslib/ranges.py
  function check_instance (line 16) | def check_instance(name, val, types):
  function check_bytes (line 23) | def check_bytes(name, val):
  function range_property (line 27) | def range_property(attr, min, max):
  function B (line 42) | def B(attr):
  function H (line 46) | def H(attr):
  function I (line 50) | def I(attr):
  function ntuple_range (line 54) | def ntuple_range(attr, n, min, max):
  function IP4 (line 76) | def IP4(attr):
  function IP6 (line 80) | def IP6(attr):

FILE: copyparty/stolen/ifaddr/__init__.py
  function nope (line 16) | def nope(include_unconfigured=False):

FILE: copyparty/stolen/ifaddr/_posix.py
  class ifaddrs (line 18) | class ifaddrs(ctypes.Structure):
  function get_adapters (line 33) | def get_adapters(include_unconfigured: bool = False) -> Iterable[shared....

FILE: copyparty/stolen/ifaddr/_shared.py
  class Adapter (line 23) | class Adapter(object):
    method __init__ (line 34) | def __init__(
    method __repr__ (line 56) | def __repr__(self) -> str:
  class IP (line 73) | class IP(object):
    method __init__ (line 78) | def __init__(
    method is_IPv4 (line 101) | def is_IPv4(self) -> bool:
    method is_IPv6 (line 109) | def is_IPv6(self) -> bool:
    method __repr__ (line 116) | def __repr__(self) -> str:
  class sockaddr (line 131) | class sockaddr(ctypes.Structure):
  class sockaddr_in (line 138) | class sockaddr_in(ctypes.Structure):
  class sockaddr_in6 (line 147) | class sockaddr_in6(ctypes.Structure):
  class sockaddr (line 159) | class sockaddr(ctypes.Structure):  # type: ignore
  class sockaddr_in (line 162) | class sockaddr_in(ctypes.Structure):  # type: ignore
  class sockaddr_in6 (line 170) | class sockaddr_in6(ctypes.Structure):  # type: ignore
  function sockaddr_to_ip (line 180) | def sockaddr_to_ip(
  function ipv6_prefixlength (line 199) | def ipv6_prefixlength(address: ipaddress.IPv6Address) -> int:

FILE: copyparty/stolen/ifaddr/_win32.py
  class SOCKET_ADDRESS (line 20) | class SOCKET_ADDRESS(ctypes.Structure):
  class IP_ADAPTER_UNICAST_ADDRESS (line 27) | class IP_ADAPTER_UNICAST_ADDRESS(ctypes.Structure):
  class IP_ADAPTER_ADDRESSES (line 46) | class IP_ADAPTER_ADDRESSES(ctypes.Structure):
  function enumerate_interfaces_of_adapter (line 68) | def enumerate_interfaces_of_adapter(
  function get_adapters (line 90) | def get_adapters(include_unconfigured: bool = False) -> Iterable[shared....

FILE: copyparty/stolen/qrcodegen.py
  function num_char_count_bits (line 25) | def num_char_count_bits(ver: int) -> int:
  class Ecc (line 29) | class Ecc(object):
    method __init__ (line 33) | def __init__(self, i: int, fb: int) -> None:
  class QrSegment (line 49) | class QrSegment(object):
    method make_seg (line 51) | def make_seg(data: Union[bytes, Sequence[int]]) -> "QrSegment":
    method __init__ (line 60) | def __init__(self, numch: int, bitdata: Sequence[int]) -> None:
    method get_total_bits (line 67) | def get_total_bits(segs: Sequence["QrSegment"], ver: int) -> Optional[...
  class QrCode (line 77) | class QrCode(object):
    method encode_binary (line 79) | def encode_binary(data: Union[bytes, Sequence[int]]) -> "QrCode":
    method encode_segments (line 83) | def encode_segments(
    method __init__ (line 141) | def __init__(
    method _draw_function_patterns (line 176) | def _draw_function_patterns(self) -> None:
    method _draw_format_bits (line 204) | def _draw_format_bits(self, mask: int) -> None:
    method _draw_ver (line 229) | def _draw_ver(self) -> None:
    method _draw_finder_pattern (line 248) | def _draw_finder_pattern(self, x: int, y: int) -> None:
    method _draw_alignment_pattern (line 258) | def _draw_alignment_pattern(self, x: int, y: int) -> None:
    method _set_function_module (line 263) | def _set_function_module(self, x: int, y: int, isdark: bool) -> None:
    method _add_ecc_and_interleave (line 267) | def _add_ecc_and_interleave(self, data: bytearray) -> bytes:
    method _draw_codewords (line 303) | def _draw_codewords(self, data: bytes) -> None:
    method _apply_mask (line 323) | def _apply_mask(self, mask: int) -> None:
    method _get_penalty_score (line 331) | def _get_penalty_score(self) -> int:
    method _get_alignment_pattern_positions (line 412) | def _get_alignment_pattern_positions(self) -> List[int]:
    method _get_num_raw_data_modules (line 429) | def _get_num_raw_data_modules(ver: int) -> int:
    method _get_num_data_codewords (line 440) | def _get_num_data_codewords(ver: int, ecl: Ecc) -> int:
    method _reed_solomon_compute_divisor (line 448) | def _reed_solomon_compute_divisor(degree: int) -> bytes:
    method _reed_solomon_compute_remainder (line 471) | def _reed_solomon_compute_remainder(data: bytes, divisor: bytes) -> by...
    method _reed_solomon_multiply (line 482) | def _reed_solomon_multiply(x: int, y: int) -> int:
    method _finder_penalty_count_patterns (line 492) | def _finder_penalty_count_patterns(self, runhistory: collections.deque...
    method _finder_penalty_terminate_and_count (line 504) | def _finder_penalty_terminate_and_count(
    method _finder_penalty_add_history (line 517) | def _finder_penalty_add_history(
  class _BitBuffer (line 556) | class _BitBuffer(list):  # type: ignore
    method append_bits (line 557) | def append_bits(self, val: int, n: int) -> None:
  function _get_bit (line 564) | def _get_bit(x: int, i: int) -> bool:
  class DataTooLongError (line 568) | class DataTooLongError(ValueError):

FILE: copyparty/stolen/surrogateescape.py
  function surrogateescape_handler (line 35) | def surrogateescape_handler(exc: Any) -> tuple[str, int]:
  class NotASurrogateError (line 62) | class NotASurrogateError(Exception):
  function replace_surrogate_encode (line 66) | def replace_surrogate_encode(mystring: str) -> str:
  function replace_surrogate_decode (line 92) | def replace_surrogate_decode(mybytes: bytes) -> str:
  function encodefilename (line 113) | def encodefilename(fn: str) -> bytes:
  function decodefilename (line 153) | def decodefilename(fn: bytes) -> str:
  function register_surrogateescape (line 170) | def register_surrogateescape() -> None:

FILE: copyparty/sutil.py
  class StreamArc (line 24) | class StreamArc(object):
    method __init__ (line 25) | def __init__(
    method gen (line 38) | def gen(self) -> Generator[Optional[bytes], None, None]:
    method stop (line 41) | def stop(self) -> None:
  function gfilter (line 45) | def gfilter(
  function enthumb (line 84) | def enthumb(
  function errdesc (line 109) | def errdesc(

FILE: copyparty/svchub.py
  class SvcHub (line 112) | class SvcHub(object):
    method __init__ (line 123) | def __init__(
    method _db_onfail_ses (line 489) | def _db_onfail_ses(self) -> None:
    method _db_onfail_idp (line 492) | def _db_onfail_idp(self) -> None:
    method setup_db (line 495) | def setup_db(self, which: str) -> None:
    method _create_session_db (line 588) | def _create_session_db(self, cur: "sqlite3.Cursor") -> int:
    method _create_idp_db (line 603) | def _create_idp_db(self, cur: "sqlite3.Cursor") -> int:
    method _verify_db (line 616) | def _verify_db(
    method setup_share_db (line 667) | def setup_share_db(self) -> None:
    method start_ftpd (line 772) | def start_ftpd(self) -> None:
    method restart_sftpd (line 784) | def restart_sftpd(self) -> None:
    method restart_ftpd (line 797) | def restart_ftpd(self) -> None:
    method restart_tftpd (line 812) | def restart_tftpd(self) -> None:
    method thr_httpsrv_up (line 823) | def thr_httpsrv_up(self) -> None:
    method sigterm (line 846) | def sigterm(self) -> None:
    method sticky_qr (line 849) | def sticky_qr(self) -> None:
    method _unsticky_qr (line 852) | def _unsticky_qr(self, flush=True) -> None:
    method _sticky_qr (line 857) | def _sticky_qr(self, force: bool = False) -> None:
    method _qr_thr (line 900) | def _qr_thr(self):
    method cb_httpsrv_up (line 927) | def cb_httpsrv_up(self) -> None:
    method after_httpsrv_up (line 955) | def after_httpsrv_up(self) -> None:
    method _feature_test (line 960) | def _feature_test(self) -> None:
    method _check_env (line 1014) | def _check_env(self) -> None:
    method _process_config (line 1069) | def _process_config(self) -> bool:
    method _ipa2re (line 1295) | def _ipa2re(self, txt) -> Optional[re.Pattern]:
    method _setlimits (line 1302) | def _setlimits(self) -> None:
    method _logname (line 1342) | def _logname(self) -> str:
    method _setup_logfile (line 1352) | def _setup_logfile(self, printed: str) -> None:
    method run (line 1399) | def run(self) -> None:
    method start_zeroconf (line 1438) | def start_zeroconf(self) -> None:
    method reload (line 1465) | def reload(self, rescan_all_vols: bool, up2k: bool) -> str:
    method _reload_sessions (line 1480) | def _reload_sessions(self) -> None:
    method stop_thr (line 1485) | def stop_thr(self) -> None:
    method kill9 (line 1496) | def kill9(self, delay: float = 0.0) -> None:
    method signal_handler (line 1507) | def signal_handler(self, sig: int, frame: Optional[FrameType]) -> None:
    method shutdown (line 1529) | def shutdown(self) -> None:
    method _log_disabled (line 1600) | def _log_disabled(self, src: str, msg: str, c: Union[int, str] = 0) ->...
    method _set_next_day (line 1651) | def _set_next_day(self, dt: datetime) -> None:
    method _log_enabled (line 1659) | def _log_enabled(self, src: str, msg: str, c: Union[int, str] = 0) -> ...
    method _log_en_f2 (line 1724) | def _log_en_f2(self, src: str, msg: str, c: Union[int, str] = 0) -> None:
    method pr (line 1787) | def pr(self, *a: Any, **ka: Any) -> None:
    method check_mp_support (line 1795) | def check_mp_support(self) -> str:
    method check_mp_enable (line 1811) | def check_mp_enable(self) -> bool:
    method sd_notify (line 1837) | def sd_notify(self) -> None:
    method log_stacks (line 1856) | def log_stacks(self) -> None:
    method check_ver (line 1869) | def check_ver(self) -> None:

FILE: copyparty/szip.py
  function dostime2unix (line 19) | def dostime2unix(buf: bytes) -> int:
  function unixtime2dos (line 38) | def unixtime2dos(ts: int) -> bytes:
  function gen_fdesc (line 48) | def gen_fdesc(sz: int, crc32: int, z64: bool) -> bytes:
  function gen_hdr (line 55) | def gen_hdr(
  function gen_ecdr (line 144) | def gen_ecdr(
  function gen_ecdr64 (line 174) | def gen_ecdr64(
  function gen_ecdr64_loc (line 200) | def gen_ecdr64_loc(ecdr64_pos: int) -> bytes:
  class StreamZip (line 215) | class StreamZip(StreamArc):
    method __init__ (line 216) | def __init__(
    method _ct (line 233) | def _ct(self, buf: bytes) -> bytes:
    method ser (line 237) | def ser(self, f: dict[str, Any]) -> Generator[bytes, None, None]:
    method gen (line 278) | def gen(self) -> Generator[bytes, None, None]:

FILE: copyparty/tcpsrv.py
  class TcpSrv (line 46) | class TcpSrv(object):
    method __init__ (line 52) | def __init__(self, hub: "SvcHub"):
    method nlog (line 246) | def nlog(self, msg: str, c: Union[int, str] = 0) -> None:
    method _listen (line 249) | def _listen(self, ip: str, port: int) -> None:
    method run (line 359) | def run(self) -> None:
    method _distribute_netdevs (line 421) | def _distribute_netdevs(self):
    method shutdown (line 429) | def shutdown(self) -> None:
    method netmon (line 439) | def netmon(self):
    method detect_interfaces (line 460) | def detect_interfaces(self, listen_ips: list[str]) -> dict[str, Netdev]:
    method _extdevs_nix (line 512) | def _extdevs_nix(self) -> Generator[str, None, None]:
    method _defroute (line 520) | def _defroute(self) -> str:
    method _set_wintitle (line 545) | def _set_wintitle(self, vs: dict[str, dict[str, int]]) -> None:
    method _qr (line 580) | def _qr(self, t1: dict[str, list[int]], t2: dict[str, list[int]]) -> str:
    method _qr2file (line 674) | def _qr2file(self, qrc: QrCode, txt: str):
    method _h2i (line 694) | def _h2i(self, hs):

FILE: copyparty/tftpd.py
  class SimpleNamespace (line 8) | class SimpleNamespace(object):
    method __init__ (line 9) | def __init__(self, **attr):
  function noop (line 67) | def noop(*a, **ka) -> None:
  function _serverInitial (line 71) | def _serverInitial(self, pkt: Any, raddress: str, rport: int) -> bool:
  class Tftpd (line 85) | class Tftpd(object):
    method __init__ (line 86) | def __init__(self, hub: "SvcHub") -> None:
    method nlog (line 198) | def nlog(self, msg: str, c: Union[int, str] = 0) -> None:
    method _start (line 201) | def _start(self, ip, ports):
    method stop (line 252) | def stop(self):
    method _v2a (line 259) | def _v2a(
    method _ls (line 279) | def _ls(self, vpath: str, raddress: str, rport: int, force=False) -> Any:
    method _open (line 347) | def _open(self, vpath: str, mode: str, *a: Any, **ka: Any) -> Any:
    method _mkdir (line 401) | def _mkdir(self, vpath: str, *a) -> None:
    method _unlink (line 410) | def _unlink(self, vpath: str) -> None:
    method _access (line 425) | def _access(self, *a: Any) -> bool:
    method _p_abspath (line 428) | def _p_abspath(self, vpath: str) -> str:
    method _p_normpath (line 431) | def _p_normpath(self, *a: Any) -> str:
    method _p_exists (line 434) | def _p_exists(self, vpath: str) -> bool:
    method _p_isdir (line 442) | def _p_isdir(self, vpath: str) -> bool:
    method _hook (line 450) | def _hook(self, *a: Any, **ka: Any) -> None:
    method _disarm (line 455) | def _disarm(self, fos: SimpleNamespace) -> None:
  function yeet (line 487) | def yeet(msg: str) -> None:

FILE: copyparty/th_cli.py
  class ThumbCli (line 26) | class ThumbCli(object):
    method __init__ (line 27) | def __init__(self, hsrv: "HttpSrv") -> None:
    method log (line 59) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method get (line 62) | def get(self, dbv: VFS, rem: str, mtime: float, fmt: str) -> Optional[...

FILE: copyparty/th_srv.py
  function thumb_path (line 215) | def thumb_path(histpath: str, rem: str, mtime: float, fmt: str, ffa: set...
  class ThumbSrv (line 252) | class ThumbSrv(object):
    method __init__ (line 253) | def __init__(self, hub: "SvcHub") -> None:
    method log (line 344) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method shutdown (line 347) | def shutdown(self) -> None:
    method _fire_sentinels (line 351) | def _fire_sentinels(self):
    method stopped (line 355) | def stopped(self) -> bool:
    method getres (line 359) | def getres(self, vn: VFS, fmt: str) -> tuple[int, int]:
    method get (line 364) | def get(self, ptop: str, rem: str, mtime: float, fmt: str) -> Optional...
    method getcfg (line 420) | def getcfg(self) -> dict[str, set[str]]:
    method volcfgi (line 431) | def volcfgi(self, vn: VFS) -> str:
    method volcfga (line 441) | def volcfga(self, vn: VFS) -> str:
    method writevolcfg (line 451) | def writevolcfg(self, histpath: str) -> None:
    method wait4ram (line 472) | def wait4ram(self, need: float, ttpath: str) -> None:
    method worker (line 489) | def worker(self) -> None:
    method fancy_pillow (line 616) | def fancy_pillow(self, im: "Image.Image", fmt: str, vn: VFS) -> "Image...
    method conv_image_pil (line 643) | def conv_image_pil(self, im: "Image.Image", tpath: str, fmt: str, vn: ...
    method conv_pil (line 672) | def conv_pil(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method conv_image_vips (line 677) | def conv_image_vips(
    method conv_vips (line 710) | def conv_vips(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method conv_raw (line 718) | def conv_raw(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method conv_ffmpeg (line 748) | def conv_ffmpeg(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> ...
    method _ffmpeg_im (line 763) | def _ffmpeg_im(
    method _ffmpeg_im_o (line 799) | def _ffmpeg_im_o(self, tpath: str, vn: VFS, cmd: list[bytes]) -> None:
    method _run_ff (line 823) | def _run_ff(self, cmd: list[bytes], vn: VFS, kto: str, oom: int = 400)...
    method conv_waves (line 879) | def conv_waves(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> N...
    method conv_emb_cv (line 939) | def conv_emb_cv(
    method conv_spec (line 947) | def conv_spec(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method conv_mp3 (line 1029) | def conv_mp3(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method conv_flac (line 1068) | def conv_flac(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method conv_wav (line 1093) | def conv_wav(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method conv_opus (line 1128) | def conv_opus(self, abspath: str, tpath: str, fmt: str, vn: VFS) -> None:
    method _conv_owa (line 1148) | def _conv_owa(
    method _conv_caf (line 1184) | def _conv_caf(
    method big_tags (line 1275) | def big_tags(self, raw_tags: dict[str, list[str]]) -> list[bytes]:
    method poke (line 1285) | def poke(self, tdir: str) -> None:
    method cleaner (line 1297) | def cleaner(self) -> None:
    method clean (line 1316) | def clean(self, histpath: str) -> int:
    method _clean (line 1349) | def _clean(self, cat: str, thumbpath: str) -> int:

FILE: copyparty/u2idx.py
  class U2idx (line 45) | class U2idx(object):
    method __init__ (line 46) | def __init__(self, hsrv: "HttpSrv") -> None:
    method log (line 74) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method _open_db_std (line 77) | def _open_db_std(self, *args, **kwargs):
    method _open_db_icase (line 82) | def _open_db_icase(self, *args, **kwargs):
    method shutdown (line 87) | def shutdown(self) -> None:
    method fsearch (line 107) | def fsearch(
    method get_shr (line 126) | def get_shr(self) -> Optional["sqlite3.Cursor"]:
    method get_cur (line 141) | def get_cur(self, vn: VFS) -> Optional["sqlite3.Cursor"]:
    method search (line 183) | def search(
    method run_query (line 358) | def run_query(
    method terminator (line 520) | def terminator(self, identifier: str, done_flag: list[bool]) -> None:

FILE: copyparty/up2k.py
  class Dbw (line 120) | class Dbw(object):
    method __init__ (line 121) | def __init__(self, c: "sqlite3.Cursor", n: int, nf: int, t: float) -> ...
  class Mpqe (line 128) | class Mpqe(object):
    method __init__ (line 131) | def __init__(
  class Up2k (line 149) | class Up2k(object):
    method __init__ (line 150) | def __init__(self, hub: "SvcHub") -> None:
    method init_vols (line 240) | def init_vols(self) -> None:
    method unpp (line 246) | def unpp(self) -> None:
    method reload (line 252) | def reload(self, rescan_all_vols: bool) -> None:
    method _reload_thr (line 260) | def _reload_thr(self) -> None:
    method _reload (line 277) | def _reload(self, rescan_all_vols: bool) -> None:
    method deferred_init (line 292) | def deferred_init(self) -> None:
    method log (line 319) | def log(self, msg: str, c: Union[int, str] = 0) -> None:
    method _gen_fk (line 325) | def _gen_fk(self, alg: int, salt: str, fspath: str, fsize: int, inode:...
    method _block (line 330) | def _block(self, why: str) -> None:
    method _unblock (line 334) | def _unblock(self) -> None:
    method get_state (line 340) | def get_state(self, get_q: bool, uname: str) -> str:
    method _active_uploads (line 380) | def _active_uploads(self, uname: str) -> list[tuple[float, int, int, s...
    method find_job_by_ap (line 407) | def find_job_by_ap(self, ptop: str, ap: str) -> str:
    method get_unfinished_by_user (line 424) | def get_unfinished_by_user(self, uname, ip) -> dict[str, Any]:
    method get_unfinished (line 476) | def get_unfinished(self) -> str:
    method get_volsize (line 502) | def get_volsize(self, ptop: str) -> tuple[int, int]:
    method get_volsizes (line 506) | def get_volsizes(self, ptops: list[str]) -> list[tuple[int, int]]:
    method _get_volsize (line 514) | def _get_volsize(self, ptop: str) -> tuple[int, int]:
    method rescan (line 527) | def rescan(
    method _rescan (line 533) | def _rescan(
    method _sched_rescan (line 548) | def _sched_rescan(self) -> None:
    method _check_forget_ip (line 648) | def _check_forget_ip(self) -> float:
    method _check_lifetimes (line 686) | def _check_lifetimes(self) -> float:
    method _check_shares (line 735) | def _check_shares(self) -> float:
    method _check_xiu (line 789) | def _check_xiu(self) -> float:
    method _run_xius (line 822) | def _run_xius(self, vol: VFS, cds: list[int]):
    method _run_xiu (line 829) | def _run_xiu(self, vol: VFS, cd: int):
    method _vis_job_progress (line 866) | def _vis_job_progress(self, job: dict[str, Any]) -> str:
    method _vis_reg_progress (line 871) | def _vis_reg_progress(self, reg: dict[str, dict[str, Any]]) -> list[str]:
    method _expr_idx_filter (line 879) | def _expr_idx_filter(self, flags: dict[str, Any]) -> tuple[bool, dict[...
    method init_indexes (line 889) | def init_indexes(
    method register_vpath (line 1130) | def register_vpath(
    method _verify_db_cache (line 1340) | def _verify_db_cache(self, cur: "sqlite3.Cursor", vpath: str) -> None:
    method _build_file_index (line 1369) | def _build_file_index(self, vol: VFS, all_vols: list[VFS]) -> tuple[bo...
    method _fika (line 1480) | def _fika(self, db: Dbw) -> None:
    method _build_dir (line 1497) | def _build_dir(
    method _drop_lost (line 1843) | def _drop_lost(self, cur: "sqlite3.Cursor", top: str, excl: list[str])...
    method _verify_integrity (line 1931) | def _verify_integrity(self, vol: VFS) -> int:
    method _build_tags_index (line 2070) | def _build_tags_index(self, vol: VFS) -> tuple[int, int, bool]:
    method _drop_caches (line 2092) | def _drop_caches(self) -> None:
    method _set_tagscan (line 2106) | def _set_tagscan(self, cur: "sqlite3.Cursor", need: bool) -> bool:
    method _build_tags_index_2 (line 2121) | def _build_tags_index_2(self, ptop: str) -> tuple[int, int, bool]:
    method _e2ts_q (line 2186) | def _e2ts_q(
    method _spool_warks (line 2270) | def _spool_warks(
    method _unspool (line 2300) | def _unspool(self, tf: tempfile.SpooledTemporaryFile[bytes]) -> None:
    method _flush_mpool (line 2311) | def _flush_mpool(self, wcur: "sqlite3.Cursor") -> list[str]:
    method _run_all_mtp (line 2320) | def _run_all_mtp(self, gid: int) -> None:
    method _run_one_mtp (line 2345) | def _run_one_mtp(self, ptop: str, gid: int) -> None:
    method _get_parsers (line 2493) | def _get_parsers(
    method _start_mpool (line 2539) | def _start_mpool(self) -> Queue[Mpqe]:
    method _stop_mpool (line 2554) | def _stop_mpool(self, mpool: Queue[Mpqe]) -> None:
    method _tag_thr (line 2563) | def _tag_thr(self, q: Queue[Mpqe]) -> None:
    method _log_tag_err (line 2603) | def _log_tag_err(self, parser: Any, abspath: str, ex: Any) -> None:
    method _tagscan_file (line 2607) | def _tagscan_file(
    method _tag_file (line 2645) | def _tag_file(
    method _trace (line 2684) | def _trace(self, msg: str) -> None:
    method _open_db_wd (line 2687) | def _open_db_wd(self, db_path: str) -> "sqlite3.Cursor":
    method _open_db_timeout (line 2697) | def _open_db_timeout(self, db_path, ok: list[int]) -> None:
    method _log_sqlite_incompat (line 2707) | def _log_sqlite_incompat(self, db_path, t0) -> None:
    method _orz (line 2729) | def _orz(self, db_path: str) -> "sqlite3.Cursor":
    method _open_db (line 2737) | def _open_db(self, db_path: str) -> "sqlite3.Cursor":
    method _delete_db (line 2785) | def _delete_db(self, db_path: str):
    method _backup_db (line 2793) | def _backup_db(
    method _read_ver (line 2817) | def _read_ver(self, cur: "sqlite3.Cursor") -> Optional[int]:
    method _try_create_db (line 2829) | def _try_create_db(
    method _create_db (line 2841) | def _create_db(
    method _upgrade_v4 (line 2880) | def _upgrade_v4(self, cur: "sqlite3.Cursor") -> None:
    method _upgrade_v5 (line 2891) | def _upgrade_v5(self, cur: "sqlite3.Cursor") -> None:
    method _add_dhash_tab (line 2900) | def _add_dhash_tab(self, cur: "sqlite3.Cursor") -> None:
    method _add_xiu_tab (line 2917) | def _add_xiu_tab(self, cur: "sqlite3.Cursor") -> None:
    method _add_cv_tab (line 2940) | def _add_cv_tab(self, cur: "sqlite3.Cursor") -> None:
    method _add_idx_up_vp (line 2961) | def _add_idx_up_vp(self, cur: "sqlite3.Cursor", db_path: str) -> None:
    method _add_ds_tab (line 2979) | def _add_ds_tab(self, cur: "sqlite3.Cursor") -> None:
    method wake_rescanner (line 2995) | def wake_rescanner(self):
    method handle_json (line 2999) | def handle_json(
    method _handle_json (line 3031) | def _handle_json(self, cj: dict[str, Any], depth: int = 1) -> dict[str...
    method _untaken (line 3510) | def _untaken(self, fdir: str, job: dict[str, Any], ts: float) -> str:
    method _symlink (line 3570) | def _symlink(
    method handle_chunks (line 3686) | def handle_chunks(
    method fast_confirm_chunks (line 3775) | def fast_confirm_chunks(
    method confirm_chunks (line 3789) | def confirm_chunks(
    method _confirm_chunks (line 3796) | def _confirm_chunks(
    method finish_upload (line 3830) | def finish_upload(self, ptop: str, wark: str, busy_aps: dict[str, int]...
    method _finish_upload (line 3839) | def _finish_upload(self, ptop: str, wark: str) -> None:
    method regdrop (line 3914) | def regdrop(self, ptop: str, wark: str) -> None:
    method idx_wark (line 3930) | def idx_wark(
    method db_rm (line 3983) | def db_rm(
    method db_add (line 4010) | def db_add(
    method handle_fs_abrt (line 4139) | def handle_fs_abrt(self, akey: str) -> None:
    method handle_rm (line 4142) | def handle_rm(
    method _handle_rm (line 4172) | def _handle_rm(
    method handle_cp (line 4365) | def handle_cp(self, abrt: str, uname: str, ip: str, svp: str, dvp: str...
    method _cp_file (line 4429) | def _cp_file(
    method handle_mv (line 4591) | def handle_mv(self, abrt: str, uname: str, ip: str, svp: str, dvp: str...
    method _mv_file (line 4683) | def _mv_file(
    method _copy_tags (line 4917) | def _copy_tags(
    method _find_from_vpath (line 4929) | def _find_from_vpath(
    method _forget_file (line 4958) | def _forget_file(
    method _relink (line 5018) | def _relink(
    method _get_wark (line 5145) | def _get_wark(self, cj: dict[str, Any]) -> str:
    method _hashlist_from_file (line 5170) | def _hashlist_from_file(
    method _ex_hash (line 5209) | def _ex_hash(self, ex: Exception, ap: str) -> None:
    method _new_upload (line 5219) | def _new_upload(self, job: dict[str, Any], vfs: VFS, depth: int) -> di...
    method _snapshot (line 5358) | def _snapshot(self) -> None:
    method do_snapshot (line 5371) | def do_snapshot(self) -> None:
    method _snap_reg (line 5377) | def _snap_reg(self, ptop: str, reg: dict[str, dict[str, Any]]) -> None:
    method _tagger (line 5461) | def _tagger(self) -> None:
    method _hasher (line 5511) | def _hasher(self) -> None:
    method _hash_t (line 5530) | def _hash_t(
    method hash_file (line 5580) | def hash_file(
    method do_fx_backlog (line 5609) | def do_fx_backlog(self):
    method hook_fx (line 5616) | def hook_fx(self, act: str, hr: dict[str, str], req_vp: str) -> None:
    method shutdown (line 5651) | def shutdown(self) -> None:
  function up2k_chunksize (line 5694) | def up2k_chunksize(filesize: int) -> int:
  function up2k_wark_from_hashlist (line 5707) | def up2k_wark_from_hashlist(salt: str, filesize: int, hashes: list[str])...
  function up2k_wark_from_metadata (line 5716) | def up2k_wark_from_metadata(salt: str, sz: int, lastmod: int, rd: str, f...

FILE: copyparty/util.py
  function noop (line 61) | def noop(*a, **ka):
  class _UTC (line 74) | class _UTC(tzinfo):
    method utcoffset (line 75) | def utcoffset(self, dt):
    method tzname (line 78) | def tzname(self, dt):
    method dst (line 81) | def dst(self, dt):
  function _ens (line 102) | def _ens(want: str) -> tuple[int, ...]:
  function get_adapters (line 176) | def get_adapters(include_unconfigured=False):
  class RootLogger (line 234) | class RootLogger(Protocol):
    method __call__ (line 235) | def __call__(self, src: str, msg: str, c: Union[int, str] = 0) -> None:
  class NamedLogger (line 238) | class NamedLogger(Protocol):
    method __call__ (line 239) | def __call__(self, msg: str, c: Union[int, str] = 0) -> None:
  function inet_pton (line 281) | def inet_pton(fam, ip):
  function inet_pton (line 289) | def inet_pton(fam, ip):
  function spack (line 302) | def spack(fmt: bytes, *a: Any) -> bytes:
  function sunpack (line 305) | def sunpack(fmt: bytes, a: bytes) -> tuple[Any, ...]:
  function umktrans (line 334) | def umktrans(s1, s2):
  function _add_mimes (line 478) | def _add_mimes() -> set[str]:
  function read_ram (line 600) | def read_ram() -> tuple[float, float]:
  function py_desc (line 639) | def py_desc() -> str:
  function expat_ver (line 659) | def expat_ver() -> str:
  function _sqlite_ver (line 668) | def _sqlite_ver() -> str:
  function ub64enc (line 740) | def ub64enc(bs: bytes) -> bytes:
  function ub64dec (line 744) | def ub64dec(bs: bytes) -> bytes:
  function b64enc (line 748) | def b64enc(bs: bytes) -> bytes:
  function b64dec (line 751) | def b64dec(bs: bytes) -> bytes:
  class NotUTF8 (line 768) | class NotUTF8(Exception):
  function read_utf8 (line 772) | def read_utf8(log: Optional["NamedLogger"], ap: Union[str, bytes], stric...
  class Daemon (line 803) | class Daemon(threading.Thread):
    method __init__ (line 804) | def __init__(
    method run (line 820) | def run(self):
  class Netdev (line 829) | class Netdev(object):
    method __init__ (line 830) | def __init__(self, ip: str, idx: int, name: str, desc: str):
    method __str__ (line 836) | def __str__(self):
    method __repr__ (line 839) | def __repr__(self):
    method __lt__ (line 842) | def __lt__(self, rhs):
    method __eq__ (line 845) | def __eq__(self, rhs):
  class Cooldown (line 849) | class Cooldown(object):
    method __init__ (line 850) | def __init__(self, maxage: float) -> None:
    method poke (line 856) | def poke(self, key: str) -> bool:
  class HLog (line 875) | class HLog(logging.Handler):
    method __init__ (line 876) | def __init__(self, log_func: "RootLogger") -> None:
    method __repr__ (line 882) | def __repr__(self) -> str:
    method flush (line 886) | def flush(self) -> None:
    method emit (line 889) | def emit(self, record: logging.LogRecord) -> None:
  class NetMap (line 919) | class NetMap(object):
    method __init__ (line 920) | def __init__(
    method map (line 966) | def map(self, ip: str) -> str:
    method _map (line 979) | def _map(self, ip: str) -> str:
  class UnrecvEOF (line 990) | class UnrecvEOF(OSError):
  class _Unrecv (line 994) | class _Unrecv(object):
    method __init__ (line 999) | def __init__(self, s: socket.socket, log: Optional["NamedLogger"]) -> ...
    method recv (line 1006) | def recv(self, nbytes: int, spins: int = 1) -> bytes:
    method recv_ex (line 1033) | def recv_ex(self, nbytes: int, raise_on_trunc: bool = True) -> bytes:
    method unrecv (line 1056) | def unrecv(self, buf: bytes) -> None:
  class _LUnrecv (line 1062) | class _LUnrecv(object):
    method __init__ (line 1067) | def __init__(self, s: socket.socket, log: Optional["NamedLogger"]) -> ...
    method recv (line 1073) | def recv(self, nbytes: int, spins: int) -> bytes:
    method recv_ex (line 1091) | def recv_ex(self, nbytes: int, raise_on_trunc: bool = True) -> bytes:
    method unrecv (line 1115) | def unrecv(self, buf: bytes) -> None:
  class CachedSet (line 1128) | class CachedSet(object):
    method __init__ (line 1129) | def __init__(self, maxage: float) -> None:
    method add (line 1134) | def add(self, v: Any) -> None:
    method cln (line 1137) | def cln(self) -> None:
  class CachedDict (line 1149) | class CachedDict(object):
    method __init__ (line 1150) | def __init__(self, maxage: float) -> None:
    method set (line 1155) | def set(self, k: str, v: Any) -> None:
    method get (line 1167) | def get(self, k: str) -> Optional[tuple[str, Any]]:
  class FHC (line 1179) | class FHC(object):
    class CE (line 1180) | class CE(object):
      method __init__ (line 1181) | def __init__(self, fh: typing.BinaryIO) -> None:
    method __init__ (line 1186) | def __init__(self) -> None:
    method close (line 1190) | def close(self, path: str) -> None:
    method clean (line 1202) | def clean(self) -> None:
    method pop (line 1217) | def pop(self, path: str) -> typing.BinaryIO:
    method put (line 1220) | def put(self, path: str, fh: typing.BinaryIO) -> None:
  class ProgressPrinter (line 1235) | class ProgressPrinter(threading.Thread):
    method __init__ (line 1240) | def __init__(self, log: "NamedLogger", args: argparse.Namespace) -> None:
    method run (line 1249) | def run(self) -> None:
  class MTHash (line 1286) | class MTHash(object):
    method __init__ (line 1287) | def __init__(self, cores: int):
    method hash (line 1303) | def hash(
    method worker (line 1347) | def worker(self) -> None:
    method hash_at (line 1357) | def hash_at(self, nch: int) -> tuple[int, str, int, int]:
  class HMaccas (line 1383) | class HMaccas(object):
    method __init__ (line 1384) | def __init__(self, keypath: str, retlen: int) -> None:
    method b (line 1397) | def b(self, msg: bytes) -> str:
    method s (line 1409) | def s(self, msg: str) -> str:
  class Magician (line 1413) | class Magician(object):
    method __init__ (line 1414) | def __init__(self) -> None:
    method ext (line 1419) | def ext(self, fpath: str) -> str:
  class Garda (line 1457) | class Garda(object):
    method __init__ (line 1460) | def __init__(self, cfg: str, uniq: bool = True) -> None:
    method cln (line 1474) | def cln(self, ip: str) -> None:
    method allcln (line 1493) | def allcln(self) -> None:
    method bonk (line 1499) | def bonk(self, ip: str, prev: str) -> tuple[int, str]:
  function _spopen (line 1533) | def _spopen(c, *a, **ka):
  function uprint (line 1541) | def uprint(msg: str) -> None:
  function nuprint (line 1551) | def nuprint(msg: str) -> None:
  function dedent (line 1555) | def dedent(txt: str) -> str:
  function rice_tid (line 1566) | def rice_tid() -> str:
  function trace (line 1572) | def trace(*args: Any, **kwargs: Any) -> None:
  function alltrace (line 1591) | def alltrace(verbose: bool = True) -> str:
  function start_stackmon (line 1623) | def start_stackmon(arg_str: str, nid: int) -> None:
  function stackmon (line 1630) | def stackmon(fp: str, ival: float, suffix: str) -> None:
  function start_log_thrs (line 1669) | def start_log_thrs(
  function log_thrs (line 1681) | def log_thrs(log: Callable[[str, str, int], None], ival: float, name: st...
  function _sigblock (line 1698) | def _sigblock():
  function vol_san (line 1707) | def vol_san(vols: list["VFS"], txt: bytes) -> bytes:
  function min_ex (line 1734) | def min_ex(max_lines: int = 8, reverse: bool = False) -> str:
  function ren_open (line 1744) | def ren_open(fname: str, *args: Any, **kwargs: Any) -> tuple[typing.IO[A...
  class MultipartParser (line 1846) | class MultipartParser(object):
    method __init__ (line 1847) | def __init__(
    method _read_header (line 1876) | def _read_header(self) -> tuple[str, Optional[str]]:
    method _read_data (line 1954) | def _read_data(self) -> Generator[bytes, None, None]:
    method _run_gen (line 2002) | def _run_gen(
    method _read_value (line 2028) | def _read_value(self, iterable: Iterable[bytes], max_len: int) -> bytes:
    method parse (line 2037) | def parse(self) -> None:
    method require (line 2059) | def require(self, field_name: str, max_len: int) -> str:
    method drop (line 2071) | def drop(self) -> None:
  function get_boundary (line 2079) | def get_boundary(headers: dict[str, str]) -> str:
  function read_header (line 2091) | def read_header(sr: Unrecv, t_idle: int, t_tot: int) -> list[str]:
  function rand_name (line 2123) | def rand_name(fdir: str, fn: str, rnd: int) -> str:
  function _gen_filekey (line 2144) | def _gen_filekey(alg: int, salt: str, fspath: str, fsize: int, inode: in...
  function _gen_filekey_w (line 2154) | def _gen_filekey_w(alg: int, salt: str, fspath: str, fsize: int, inode: ...
  function gen_filekey_dbg (line 2161) | def gen_filekey_dbg(
  function formatdate (line 2201) | def formatdate(ts: Optional[float] = None) -> str:
  function gencookie (line 2207) | def gencookie(
  function gen_content_disposition (line 2228) | def gen_content_disposition(fn: str) -> str:
  function humansize (line 2251) | def humansize(sz: float, terse: bool = False) -> str:
  function unhumanize (line 2265) | def unhumanize(sz: str) -> int:
  function get_spd (line 2276) | def get_spd(nbyte: int, t0: float, t: Optional[float] = None) -> str:
  function s2hms (line 2286) | def s2hms(s: float, optional_h: bool = False) -> str:
  function djoin (line 2296) | def djoin(*paths: str) -> str:
  function uncyg (line 2301) | def uncyg(path: str) -> str:
  function undot (line 2311) | def undot(path: str) -> str:
  function sanitize_fn (line 2327) | def sanitize_fn(fn: str) -> str:
  function sanitize_to (line 2334) | def sanitize_to(fn: str, tl: dict[int, int]) -> str:
  function sanitize_vpath (line 2346) | def sanitize_vpath(vp: str) -> str:
  function relchk (line 2354) | def relchk(rp: str) -> str:
  function absreal (line 2369) | def absreal(fpath: str) -> str:
  function u8safe (line 2382) | def u8safe(txt: str) -> str:
  function exclude_dotfiles (line 2389) | def exclude_dotfiles(filepaths: list[str]) -> list[str]:
  function exclude_dotfiles_ls (line 2393) | def exclude_dotfiles_ls(
  function odfusion (line 2399) | def odfusion(
  function ipnorm (line 2419) | def ipnorm(ip: str) -> str:
  function find_prefix (line 2427) | def find_prefix(ips: list[str], cidrs: list[str]) -> list[str]:
  function html_sh_esc (line 2436) | def html_sh_esc(s: str) -> str:
  function json_hesc (line 2442) | def json_hesc(s: str) -> str:
  function html_escape (line 2446) | def html_escape(s: str, quot: bool = False, crlf: bool = False) -> str:
  function html_bescape (line 2457) | def html_bescape(s: bytes, quot: bool = False, crlf: bool = False) -> by...
  function _quotep2 (line 2468) | def _quotep2(txt: str) -> str:
  function _quotep3 (line 2477) | def _quotep3(txt: str) -> str:
  function _quotep3b (line 2494) | def _quotep3b(txt: str) -> str:
  function unquote (line 2509) | def unquote(btxt: bytes) -> bytes:
  function unquotep (line 2531) | def unquotep(txt: str) -> str:
  function vroots (line 2538) | def vroots(vp1: str, vp2: str) -> tuple[str, str]:
  function vsplit (line 2555) | def vsplit(vpath: str) -> tuple[str, str]:
  function vjoin (line 2563) | def vjoin(rd: str, fn: str) -> str:
  function ujoin (line 2571) | def ujoin(rd: str, fn: str) -> str:
  function str_anchor (line 2578) | def str_anchor(txt) -> tuple[int, str]:
  function log_reloc (line 2593) | def log_reloc(
  function pathmod (line 2608) | def pathmod(
  function _w8dec2 (line 2659) | def _w8dec2(txt: bytes) -> str:
  function _w8enc2 (line 2664) | def _w8enc2(txt: str) -> bytes:
  function _w8dec3 (line 2669) | def _w8dec3(txt: bytes) -> str:
  function _w8enc3 (line 2674) | def _w8enc3(txt: str) -> bytes:
  function _msdec (line 2679) | def _msdec(txt: bytes) -> str:
  function _msaenc (line 2684) | def _msaenc(txt: str) -> bytes:
  function _uncify (line 2688) | def _uncify(txt: str) -> str:
  function _msenc (line 2696) | def _msenc(txt: str) -> bytes:
  function w8b64dec (line 2709) | def w8b64dec(txt: str) -> str:
  function w8b64enc (line 2714) | def w8b64enc(txt: str) -> str:
  function _not_actually_mbcs_enc (line 2732) | def _not_actually_mbcs_enc(txt: str) -> bytes:
  function _not_actually_mbcs_dec (line 2735) | def _not_actually_mbcs_dec(txt: bytes) -> str:
  function s3enc (line 2743) | def s3enc(mem_cur: "sqlite3.Cursor", rd: str, fn: str) -> tuple[str, str]:
  function s3dec (line 2756) | def s3dec(rd: str, fn: str) -> tuple[str, str]:
  function db_ex_chk (line 2763) | def db_ex_chk(log: "NamedLogger", ex: Exception, db_path: str) -> bool:
  function lsof (line 2771) | def lsof(log: "NamedLogger", abspath: str) -> None:
  function set_fperms (line 2780) | def set_fperms(f: Union[typing.BinaryIO, typing.IO[Any]], vf: dict[str, ...
  function set_ap_perms (line 2788) | def set_ap_perms(ap: str, vf: dict[str, Any]) -> None:
  function trystat_shutil_copy2 (line 2796) | def trystat_shutil_copy2(log: "NamedLogger", src: bytes, dst: bytes) -> ...
  function _fs_mvrm (line 2814) | def _fs_mvrm(
  function atomic_move (line 2880) | def atomic_move(log: "NamedLogger", src: str, dst: str, flags: dict[str,...
  function wunlink (line 2905) | def wunlink(log: "NamedLogger", abspath: str, flags: dict[str, Any]) -> ...
  function get_df (line 2913) | def get_df(abspath: str, prune: bool) -> tuple[int, int, str]:
  function siocoutq (line 2944) | def siocoutq(sck: socket.socket) -> int:
  function siocoutq (line 2958) | def siocoutq(sck: socket.socket) -> int:
  function shut_socket (line 2962) | def shut_socket(log: "NamedLogger", sck: socket.socket, timeout: int = 3...
  function read_socket (line 2997) | def read_socket(
  function read_socket_unbounded (line 3015) | def read_socket_unbounded(sr: Unrecv, bufsz: int) -> Generator[bytes, No...
  function read_socket_chunked (line 3023) | def read_socket_chunked(
  function list_ips (line 3068) | def list_ips() -> list[str]:
  function build_netmap (line 3080) | def build_netmap(csv: str, defer_mutex: bool = False):
  function load_ipu (line 3135) | def load_ipu(
  function load_ipr (line 3162) | def load_ipr(
  function yieldfile (line 3183) | def yieldfile(fn: str, bufsz: int) -> Generator[bytes, None, None]:
  function justcopy (line 3194) | def justcopy(
  function eol_conv (line 3214) | def eol_conv(
  function hashcopy (line 3225) | def hashcopy(
  function sendfile_py (line 3250) | def sendfile_py(
  function sendfile_kern (line 3286) | def sendfile_kern(
  function statdir (line 3341) | def statdir(
  function dir_is_empty (line 3392) | def dir_is_empty(logger: "RootLogger", scandir: bool, top: str):
  function rmdirs (line 3398) | def rmdirs(
  function rmdirs_up (line 3428) | def rmdirs_up(top: str, stop: str) -> tuple[list[str], list[str]]:
  function unescape_cookie (line 3446) | def unescape_cookie(orig: str, name: str) -> str:
  function guess_mime (line 3476) | def guess_mime(
  function safe_mime (line 3510) | def safe_mime(mime: str) -> str:
  function getalive (line 3517) | def getalive(pids: list[int], pgid: int) -> list[int]:
  function killtree (line 3536) | def killtree(root: int) -> None:
  function _find_nice (line 3585) | def _find_nice() -> str:
  function runcmd (line 3609) | def runcmd(
  function chkcmd (line 3683) | def chkcmd(argv: Union[list[bytes], list[str]], **ka: Any) -> tuple[str,...
  function mchkcmd (line 3692) | def mchkcmd(argv: Union[list[bytes], list[str]], timeout: float = 10) ->...
  function retchk (line 3703) | def retchk(
  function _parsehook (line 3756) | def _parsehook(
  function runihook (line 3829) | def runihook(
  function _zmq_hook (line 3897) | def _zmq_hook(
  function _runhook (line 3998) | def _runhook(
  function runhook (line 4102) | def runhook(
  function loadpy (line 4161) | def loadpy(ap: str, hot: bool) -> Any:
  function gzip_orig_sz (line 4187) | def gzip_orig_sz(fn: str) -> int:
  function gzip_file_orig_sz (line 4192) | def gzip_file_orig_sz(f) -> int:
  function align_tab (line 4200) | def align_tab(lines: list[str]) -> list[str]:
  function visual_length (line 4216) | def visual_length(txt: str) -> int:
  function wrap (line 4261) | def wrap(txt: str, maxlen: int, maxlen2: int) -> list[str]:
  function termsize (line 4295) | def termsize() -> tuple[int, int]:
  function hidedir (line 4328) | def hidedir(dp) -> None:
  function _lock_file_noop (line 4343) | def _lock_file_noop(ap: str) -> bool:
  function _lock_file_ioctl (line 4347) | def _lock_file_ioctl(ap: str) -> bool:
  function _lock_file_windows (line 4376) | def _lock_file_windows(ap: str) -> bool:
  function _open_nolock_windows (line 4407) | def _open_nolock_windows(bap: Union[str, bytes], *a, **ka) -> typing.Bin...
  function _pkg_resource_exists (line 4451) | def _pkg_resource_exists(pkg: str, name: str) -> bool:
  function stat_resource (line 4460) | def stat_resource(E: EnvParams, name: str):
  function _find_impresource (line 4467) | def _find_impresource(pkg: types.ModuleType, name: str):
  function _has_resource (line 4480) | def _has_resource(name: str):
  function has_resource (line 4507) | def has_resource(E: EnvParams, name: str):
  function load_resource (line 4511) | def load_resource(E: EnvParams, name: str, mode="rb") -> IO[bytes]:
  class Pebkac (line 4541) | class Pebkac(Exception):
    method __init__ (line 4542) | def __init__(
    method __repr__ (line 4549) | def __repr__(self) -> str:
  class WrongPostKey (line 4553) | class WrongPostKey(Pebkac):
    method __init__ (line 4554) | def __init__(

FILE: copyparty/web/baguettebox.js
  function run (line 146) | function run(selector, userOptions) {
  function bindImageClickListeners (line 152) | function bindImageClickListeners(selector, userOptions) {
  function bindCbzClickListeners (line 199) | function bindCbzClickListeners(tagsNodeList, userOptions) {
  function fillCbzGallery (line 237) | function fillCbzGallery(gallery, cbzElement, eventHandler) {
  function clearCachedData (line 278) | function clearCachedData() {
  function removeFromCache (line 284) | function removeFromCache(selector) {
  function buildOverlay (line 301) | function buildOverlay() {
  function halp (line 345) | function halp() {
  function keyDownHandler (line 384) | function keyDownHandler(e) {
  function anim (line 454) | function anim() {
  function toggleReadDir (line 464) | function toggleReadDir() {
  function setVmode (line 479) | function setVmode() {
  function tglVmode (line 510) | function tglVmode() {
  function findfile (line 525) | function findfile() {
  function tglfull (line 535) | function tglfull() {
  function setzoom (line 550) | function setzoom() {
  function tglsel (line 556) | function tglsel() {
  function dlpic (line 563) | function dlpic() {
  function selbg (line 568) | function selbg() {
  function btnState (line 586) | function btnState(btn, sel) {
  function keyUpHandler (line 593) | function keyUpHandler(e) {
  method passive (line 608) | get passive() {
  function bindEvents (line 622) | function bindEvents() {
  function unbindEvents (line 646) | function unbindEvents() {
  function prepareOverlay (line 671) | function prepareOverlay(gallery, userOptions) {
  function setOptions (line 695) | function setOptions(newOptions) {
  function showOverlay (line 735) | function showOverlay(chosenImageIndex) {
  function hideOverlay (line 784) | function hideOverlay(e, dtor) {
  function unvid (line 831) | function unvid(keep) {
  function unfig (line 849) | function unfig(keep) {
  function lerr (line 867) | function lerr() {
  function loadImage (line 889) | function loadImage(index, callback) {
  function ppHandler (line 962) | function ppHandler() {
  function showRightImage (line 971) | function showRightImage(e) {
  function showLeftImage (line 977) | function showLeftImage(e) {
  function showNextImageIgnoreReadDir (line 983) | function showNextImageIgnoreReadDir(e) {
  function showPreviousImageIgnoreReadDir (line 988) | function showPreviousImageIgnoreReadDir(e) {
  function showFirstImage (line 993) | function showFirstImage(e) {
  function showLastImage (line 1000) | function showLastImage(e) {
  function show (line 1007) | function show(index, gallery) {
  function rotn (line 1060) | function rotn(n, asap) {
  function rotl (line 1119) | function rotl() {
  function rotr (line 1122) | function rotr() {
  function unrot (line 1125) | function unrot() {
  function vid (line 1143) | function vid() {
  function vidimg (line 1150) | function vidimg() {
  function playvid (line 1157) | function playvid(play) {
  function playpause (line 1172) | function playpause() {
  function relseek (line 1178) | function relseek(sec) {
  function vidEnd (line 1186) | function vidEnd() {
  function setloop (line 1191) | function setloop(side) {
  function loopchk (line 1208) | function loopchk() {
  function urltime (line 1219) | function urltime(txt) {
  function mp_ctl (line 1223) | function mp_ctl() {
  function show_buttons (line 1235) | function show_buttons(v) {
  function bounceAnimation (line 1241) | function bounceAnimation(direction) {
  function updateOffset (line 1249) | function updateOffset(noTransition) {
  function preloadNext (line 1321) | function preloadNext(index) {
  function preloadPrev (line 1330) | function preloadPrev(index) {
  function bind (line 1339) | function bind(element, event, callback, options) {
  function unbind (line 1343) | function unbind(element, event, callback, options) {
  function destroyPlugin (line 1347) | function destroyPlugin() {

FILE: copyparty/web/browser.js
  function langtest (line 717) | function langtest() {
  function langtest2 (line 722) | function langtest2() {
  function opclick (line 1080) | function opclick(e) {
  function goto (line 1100) | function goto(dest) {
  function read_sbw (line 1144) | function read_sbw() {
  function check_image_support (line 1157) | function check_image_support(format, uri) {
  function set_files_html (line 1184) | function set_files_html(html) {
  function draw_pb_mode (line 1405) | function draw_pb_mode() {
  function set_pb_mode (line 1414) | function set_pb_mode(e) {
  function set_tint (line 1421) | function set_tint() {
  function setaufollow (line 1528) | function setaufollow() {
  function announce (line 1533) | function announce() {
  function MPlayer (line 1646) | function MPlayer() {
  function ft2dict (line 1862) | function ft2dict(tr, skip) {
  function canvas_cfg (line 2007) | function canvas_cfg(can) {
  function glossy_grad (line 2024) | function glossy_grad(can, h, s, l) {
  function mmove (line 2078) | function mmove(e) {
  function menter (line 2091) | function menter() {
  function mleave (line 2095) | function mleave() {
  function mousedown (line 2314) | function mousedown(e) {
  function mousemove (line 2318) | function mousemove(e) {
  function seek_au_mul (line 2361) | function seek_au_mul(mul) {
  function seek_au_rel (line 2366) | function seek_au_rel(sec) {
  function seek_au_sec (line 2371) | function seek_au_sec(seek) {
  function song_skip (line 2389) | function song_skip(n, dirskip) {
  function next_song (line 2405) | function next_song(e) {
  function last_song (line 2424) | function last_song(e) {
  function prev_song (line 2438) | function prev_song(e) {
  function dl_song (line 2450) | function dl_song() {
  function sel_song (line 2462) | function sel_song() {
  function playpause (line 2472) | function playpause(e) {
  function mplay (line 2490) | function mplay(e) {
  function mpause (line 2498) | function mpause(e) {
  function repreload (line 2570) | function repreload() {
  function updater_impl (line 2574) | function updater_impl() {
  function ev_play (line 2674) | function ev_play(e) {
  function start_actx (line 2688) | function start_actx() {
  function setvis (line 2732) | function setvis(vis) {
  function add_ss (line 2889) | function add_ss() {
  function add_eq (line 2895) | function add_eq() {
  function eq_step (line 2978) | function eq_step(e) {
  function adj_band (line 2994) | function adj_band(that, step) {
  function adj_drc (line 3020) | function adj_drc() {
  function adj_ss (line 3045) | function adj_ss() {
  function eq_mod (line 3068) | function eq_mod(e) {
  function eq_keydown (line 3073) | function eq_keydown(e) {
  function showdrc (line 3079) | function showdrc() {
  function play (line 3167) | function play(tid, is_ev, seek) {
  function scroll2playing (line 3316) | function scroll2playing() {
  function evau_end (line 3325) | function evau_end(e) {
  function evau_error (line 3337) | function evau_error(e) {
  function autoplay_blocked (line 3427) | function autoplay_blocked(seek) {
  function scan_hash (line 3448) | function scan_hash(v) {
  function eval_hash (line 3475) | function eval_hash() {
  function setsb (line 3595) | function setsb() {
  function setacmp (line 3602) | function setacmp() {
  function read_dsort (line 3617) | function read_dsort(txt) {
  function getsort (line 3644) | function getsort() {
  function sortfiles (line 3657) | function sortfiles(nodes) {
  function fmt_ren (line 3749) | function fmt_ren(re, md, fmt) {
  function enre_rw_edit (line 3847) | function enre_rw_edit() {
  function fs_abrt (line 3853) | function fs_abrt() {
  function setexp (line 4031) | function setexp(a, b) {
  function setdef (line 4043) | function setdef() {
  function shspf (line 4078) | function shspf() {
  function shr_cb (line 4102) | function shr_cb() {
  function sadv (line 4299) | function sadv() {
  function rn_ok (line 4308) | function rn_ok(n, ok) {
  function rn_reset (line 4313) | function rn_reset(n) {
  function rn_cancel (line 4318) | function rn_cancel(e) {
  function spresets (line 4340) | function spresets() {
  function rn_apply (line 4437) | function rn_apply(e) {
  function rn_apply_loop (line 4458) | function rn_apply_loop() {
  function deleter (line 4511) | function deleter(err) {
  function delete_cb (line 4528) | function delete_cb() {
  function paster (line 4785) | function paster() {
  function paste_cb (line 4810) | function paste_cb() {
  function okgo (line 4821) | function okgo() {
  function rn_apply (line 4843) | function rn_apply(e) {
  function rn_skip (line 4852) | function rn_skip(e) {
  function rn_cancel (line 4861) | function rn_cancel(e) {
  function setcnmt (line 4870) | function setcnmt(sel) {
  function onmsg (line 4908) | function onmsg(msg) {
  function loading (line 5156) | function loading(e) {
  function load_cb (line 5173) | function load_cb(e) {
  function render (line 5183) | function render(doc, no_push) {
  function setln (line 5560) | function setln(v) {
  function setsz (line 5572) | function setsz(v) {
  function gclick1 (line 5583) | function gclick1(e) {
  function gclick2 (line 5590) | function gclick2(e) {
  function gclick (line 5597) | function gclick(e, dbl) {
  function loadgrid (line 5725) | function loadgrid() {
  function th_onload (line 5953) | function th_onload(el) {
  function tree_scrollto (line 5958) | function tree_scrollto(e) {
  function tree_scrolltoo (line 5965) | function tree_scrolltoo(q) {
  function tree_neigh (line 5985) | function tree_neigh(n, ratelimit) {
  function tree_up (line 6021) | function tree_up(justgo) {
  function hkhelp (line 6045) | function hkhelp() {
  function fselfunw (line 6073) | function fselfunw(e, ae, d, rem) {
  function srch_msg (line 6422) | function srch_msg(err, txt) {
  function ev_search_input (line 6432) | function ev_search_input() {
  function ev_search_keydown (line 6457) | function ev_search_keydown(e) {
  function try_search (line 6462) | function try_search(v) {
  function set_vq (line 6471) | function set_vq() {
  function encode_query (line 6481) | function encode_query() {
  function do_search (line 6570) | function do_search() {
  function xhr_search_results (line 6584) | function xhr_search_results() {
  function unsearch (line 6676) | function unsearch(e) {
  function moar (line 6686) | function moar(e) {
  function ev_load_m3u (line 6696) | function ev_load_m3u(e) {
  function load_m3u (line 6712) | function load_m3u(url) {
  function render_m3u (line 6721) | function render_m3u() {
  function aligngriditems (line 6784) | function aligngriditems() {
  function setwrap (line 6889) | function setwrap(v) {
  function setidxh (line 6895) | function setidxh(v) {
  function unmenter (line 6949) | function unmenter() {
  function onscroll (line 6971) | function onscroll() {
  function onscroll2 (line 6976) | function onscroll2() {
  function onresize (line 7060) | function onresize(e) {
  function get_tree (line 7099) | function get_tree(top, dst, rst) {
  function reload_tree (line 7205) | function reload_tree() {
  function compy (line 7253) | function compy() {
  function menter (line 7264) | function menter(e) {
  function mleave (line 7275) | function mleave(e) {
  function bad_proxy (line 7280) | function bad_proxy(e) {
  function treegrow (line 7343) | function treegrow(e) {
  function recvls (line 7358) | function recvls() {
  function asdf (line 7620) | function asdf() {
  function memo_dk (line 7685) | function memo_dk(vp, k) {
  function parsetree (line 7771) | function parsetree(res, top) {
  function scaletree (line 7812) | function scaletree(e) {
  function enspin (line 7868) | function enspin(i) {
  function apply_perms (line 7912) | function apply_perms(res) {
  function tr2id (line 8027) | function tr2id(tr) {
  function find_file_col (line 8037) | function find_file_col(txt) {
  function mk_files_header (line 8058) | function mk_files_header(taglist) {
  function hcols_click (line 8110) | function hcols_click(e) {
  function set_key_notation (line 8308) | function set_key_notation() {
  function load_notation (line 8313) | function load_notation(notation) {
  function render (line 8324) | function render() {
  function try_render (line 8353) | function try_render() {
  function freshen (line 8397) | function freshen() {
  function freshen (line 8454) | function freshen() {
  function onch (line 8464) | function onch(e) {
  function setfmt (line 8468) | function setfmt(fmt) {
  function freshen (line 8479) | function freshen() {
  function setlang (line 8489) | function setlang(e) {
  function render (line 8531) | function render() {
  function try_render (line 8564) | function try_render() {
  function change_fmt (line 8573) | function change_fmt(e) {
  function cb (line 8882) | function cb() {
  function cb (line 8940) | function cb() {
  function show_md (line 9033) | function show_md(md, name, div, url, depth) {
  function set_tabindex (line 9115) | function set_tabindex() {
  function show_readme (line 9122) | function show_readme(md, n) {
  function sandbox (line 9135) | function sandbox(tgt, rules, allow, cls, html) {
  function ev_row_tgl (line 9268) | function ev_row_tgl(e) {
  function unpost_load_cb (line 9293) | function unpost_load_cb() {
  function linklist (line 9360) | function linklist() {
  function unpost_delete_cb (line 9370) | function unpost_delete_cb() {
  function goto_unpost (line 9489) | function goto_unpost(e) {
  function wintitle (line 9494) | function wintitle(txt, noname) {
  function persist_scroll (line 9524) | function persist_scroll() {
  function restore_scroll (line 9538) | function restore_scroll() {
  function mktemp (line 9623) | function mktemp(is_dir) {
  function show (line 9717) | function show(x, y, target, isGrid) {
  function reload_mp (line 9813) | function reload_mp() {
  function reload_browser (line 9840) | function reload_browser() {
  function unbox (line 9894) | function unbox() {
  function getpp (line 9911) | function getpp(e) {
  function sel_toggle (line 9916) | function sel_toggle(el, m) {
  function bob (line 9928) | function bob(b1, b2) {
  function sel_start (line 9933) | function sel_start(e) {
  function start_drag (line 9955) | function start_drag() {
  function sel_move (line 9966) | function sel_move(e) {
  function sel_end (line 9998) | function sel_end(e) {
  function dsel_init (line 10013) | function dsel_init() {
  function detectSilence (line 10065) | function detectSilence() {

FILE: copyparty/web/dbg-audio.js
  function draw (line 37) | function draw() {

FILE: copyparty/web/md.js
  function copydom (line 71) | function copydom(src, dst, lv) {
  function convert_markdown (line 196) | function convert_markdown(md_text, dest_dom) {
  function init_toc (line 359) | function init_toc() {

FILE: copyparty/web/md2.js
  function genmapq (line 35) | function genmapq(dom, query) {
  function genmap (line 76) | function genmap(dom, oldmap) {
  function Modpoll (line 237) | function Modpoll() {
  function save (line 337) | function save(e) {
  function save_cb (line 374) | function save_cb() {
  function run_savechk (line 410) | function run_savechk(lastmod, txt, btn, ntry) {
  function savechk_cb (line 424) | function savechk_cb() {
  function linebounds (line 472) | function linebounds(just_car, greedy_growth) {
  function getsel (line 507) | function getsel() {
  function setsel (line 517) | function setsel(s) {
  function md_cut (line 532) | function md_cut(cut) {
  function md_indent (line 546) | function md_indent(dedent) {
  function md_header (line 563) | function md_header(dedent) {
  function md_home (line 580) | function md_home(shift) {
  function md_newline (line 611) | function md_newline() {
  function md_backspace (line 636) | function md_backspace() {
  function md_p_jump (line 665) | function md_p_jump(down) {
  function reLastIndexOf (line 688) | function reLastIndexOf(txt, ptn, end) {
  function fmt_json (line 703) | function fmt_json(e) {
  function fmt_json2 (line 712) | function fmt_json2() {
  function fmt_table (line 736) | function fmt_table(e) {
  function fmt_table2 (line 745) | function fmt_table2() {
  function mark_uni (line 893) | function mark_uni(e) {
  function iter_uni (line 909) | function iter_uni(e) {
  function cfg_uni (line 931) | function cfg_uni(e) {

FILE: copyparty/web/mde.js
  function set_jumpto (line 73) | function set_jumpto() {
  function jumpto (line 77) | function jumpto(ev) {
  function md_changed (line 92) | function md_changed(mde, on_srv) {
  function save (line 103) | function save(mde) {
  function save_cb (line 136) | function save_cb() {
  function save_chk (line 182) | function save_chk() {

FILE: copyparty/web/rups.js
  function render (line 5) | function render() {
  function ask (line 41) | function ask(e) {

FILE: copyparty/web/shares.js
  function rm (line 9) | function rm() {
  function bump (line 18) | function bump() {
  function cb (line 28) | function cb() {
  function qr (line 40) | function qr(e) {
  function showqr (line 55) | function showqr(href) {

FILE: copyparty/web/splash.js
  function redo (line 81) | function redo(msg) {
  function mok (line 87) | function mok(v) {
  function stars (line 95) | function stars() {

FILE: copyparty/web/svcs.js
  function add_dls (line 14) | function add_dls() {
  function esetos (line 34) | function esetos(e) {
  function setos (line 39) | function setos(os) {
  function setpw (line 57) | function setpw(e) {
  function askpw (line 77) | function askpw() {

FILE: copyparty/web/up2k.js
  function goto_up2k (line 17) | function goto_up2k() {
  function up2k_flagbus (line 60) | function up2k_flagbus() {
  function U2pvis (line 157) | function U2pvis(act, btns, uc, st) {
  function Donut (line 630) | function Donut(uc, st) {
  function sfx_nice (line 751) | function sfx_nice() {
  function fsearch_explain (line 783) | function fsearch_explain(n) {
  function up2k_init (line 794) | function up2k_init(subtle) {
  function warn_uploader_busy (line 3433) | function warn_uploader_busy(e) {

FILE: copyparty/web/util.js
  function mknod (line 89) | function mknod(et, eid, html) {
  function qsr (line 102) | function qsr(sel) {
  function esc (line 112) | function esc(txt) {
  function basenames (line 122) | function basenames(txt) {
  function vis_exh (line 168) | function vis_exh(msg, url, lineNo, columnNo, error) {
  function ignex (line 290) | function ignex(all) {
  function noop (line 305) | function noop() { }
  function ctrl (line 308) | function ctrl(e) {
  function anymod (line 313) | function anymod(e, shift_ok) {
  function ev (line 319) | function ev(e) {
  function noope (line 344) | function noope(e) {
  function import_js (line 433) | function import_js(url, cb, ecb) {
  function unsmart (line 448) | function unsmart(txt) {
  function namesan (line 457) | function namesan(txt, win, fslash) {
  function crc32 (line 496) | function crc32(str) {
  function randstr (line 505) | function randstr(len) {
  function clmod (line 523) | function clmod(el, cls, add) {
  function clgot (line 555) | function clgot(el, cls) {
  function setcvar (line 567) | function setcvar(k, v) {
  function yscroll (line 586) | function yscroll() {
  function xscroll (line 599) | function xscroll() {
  function showsort (line 614) | function showsort(tab) {
  function st_cmp_num (line 649) | function st_cmp_num(a, b) {
  function st_cmp_nat (line 658) | function st_cmp_nat(a, b) {
  function st_cmp_gen (line 667) | function st_cmp_gen(a, b) {
  function sortTable (line 676) | function sortTable(table, col, cb) {
  function makeSortable (line 745) | function makeSortable(table, cb) {
  function assert_vp (line 759) | function assert_vp(path) {
  function linksplit (line 769) | function linksplit(rp, base, id) {
  function vsplit (line 813) | function vsplit(vp) {
  function vjoin (line 825) | function vjoin(p1, p2) {
  function addq (line 848) | function addq(url, q) {
  function uricom_enc (line 857) | function uricom_enc(txt, do_fb_enc) {
  function url_enc (line 870) | function url_enc(txt) {
  function uricom_dec (line 881) | function uricom_dec(txt) {
  function uricom_sdec (line 892) | function uricom_sdec(txt) {
  function uricom_adec (line 903) | function uricom_adec(arr, li) {
  function get_evpath (line 914) | function get_evpath() {
  function noq_href (line 927) | function noq_href(el) {
  function pad2 (line 932) | function pad2(v) {
  function unix2iso (line 937) | function unix2iso(ts) {
  function unix2iso_localtime (line 942) | function unix2iso_localtime(ts) {
  function s2ms (line 955) | function s2ms(s) {
  function f2f (line 970) | function f2f(val, nd) {
  function humansize (line 983) | function humansize(b, terse) {
  function humansize_su (line 989) | function humansize_su(b) {
  function humansize_0 (line 994) | function humansize_0(b) {
  function humansize_1 (line 997) | function humansize_1(b) {
  function humansize_2g (line 1000) | function humansize_2g(b) {
  function humansize_3g (line 1004) | function humansize_3g(b) {
  function humansize_4g (line 1008) | function humansize_4g(b) {
  function humansize_5g (line 1012) | function humansize_5g(b) {
  function humansize_2 (line 1016) | function humansize_2(b) {
  function humansize_3 (line 1019) | function humansize_3(b) {
  function humansize_4 (line 1022) | function humansize_4(b) {
  function humansize_5 (line 1025) | function humansize_5(b) {
  function humansize_2c (line 1028) | function humansize_2c(b) {
  function humansize_3c (line 1032) | function humansize_3c(b) {
  function humansize_4c (line 1036) | function humansize_4c(b) {
  function humansize_5c (line 1040) | function humansize_5c(b) {
  function humansize_fuzzy (line 1044) | function humansize_fuzzy(b) {
  function humantime (line 1073) | function humantime(v) {
  function shumantime (line 1086) | function shumantime(v, long) {
  function lhumantime (line 1112) | function lhumantime(v) {
  function clamp (line 1134) | function clamp(v, a, b) {
  function has (line 1139) | function has(haystack, needle) {
  function apop (line 1150) | function apop(arr, v) {
  function jcp1 (line 1157) | function jcp1(obj) {
  function jcp2 (line 1162) | function jcp2(src) {
  function sdrop (line 1184) | function sdrop(key) {
  function sread (line 1191) | function sread(key, al) {
  function swrite (line 1201) | function swrite(key, val) {
  function jread (line 1211) | function jread(key, fb) {
  function jwrite (line 1225) | function jwrite(key, val) {
  function icfg_get (line 1232) | function icfg_get(name, defval) {
  function fcfg_get (line 1236) | function fcfg_get(name, defval) {
  function scfg_get (line 1249) | function scfg_get(name, defval) {
  function bcfg_get (line 1262) | function bcfg_get(name, defval) {
  function bcfg_set (line 1277) | function bcfg_set(name, val) {
  function bcfg_upd_ui (line 1283) | function bcfg_upd_ui(name, val) {
  function bcfg_bind (line 1296) | function bcfg_bind(obj, oname, cname, defval, cb, un_ev) {
  function scfg_bind (line 1314) | function scfg_bind(obj, oname, cname, defval, cb) {
  function setck (line 1329) | function setck(v, cb) {
  function hist_push (line 1343) | function hist_push(url) {
  function hist_replace (line 1351) | function hist_replace(url) {
  function sethash (line 1359) | function sethash(hv) {
  function dl_file (line 1369) | function dl_file(url) {
  function cliptxt (line 1381) | function cliptxt(txt, ok) {
  function Debounce (line 1402) | function Debounce(delay) {
  function lf2br (line 1676) | function lf2br(txt) {
  function hunpre (line 1686) | function hunpre(txt) {
  function unpre (line 1689) | function unpre(txt) {
  function winpopup (line 2021) | function winpopup(txt) {
  function repl_load (line 2033) | function repl_load() {
  function repl (line 2086) | function repl(e) {
  function load_md_plug (line 2123) | function load_md_plug(md_text, plug_type, defer) {
  function md_thumbs (line 2175) | function md_thumbs(md) {
  function md_th_set (line 2203) | function md_th_set() {
  function md_th_click (line 2208) | function md_th_click(e) {
  function cprop (line 2284) | function cprop(name) {
  function bchrome (line 2289) | function bchrome() {
  function xhrchk (line 2316) | function xhrchk(xhr, prefix, e404, lvl, tag) {

FILE: copyparty/web/w.hash.js
  function hex2u8 (line 4) | function hex2u8(txt) {
  function esc (line 7) | function esc(txt) {
  function load_fb (line 30) | function load_fb() {

FILE: docs/chunksizes.py
  function humansize (line 9) | def humansize(sz, terse=False):
  function up2k_chunksize (line 24) | def up2k_chunksize(filesize):
  function main (line 37) | def main():

FILE: scripts/deps-docker/genprism.py
  function read_json (line 12) | def read_json(path):
  function get_prism_version (line 16) | def get_prism_version(prism_path):
  function get_prism_components (line 22) | def get_prism_components(prism_path):
  function parse_prism_configuration (line 28) | def parse_prism_configuration(url_str):
  function paths_of_component (line 35) | def paths_of_component(prism_path, kind, components, name, minified):
  function read_component_contents (line 68) | def read_component_contents(kv_paths):
  function get_language_dependencies (line 72) | def get_language_dependencies(components, name):
  function make_header (line 83) | def make_header(prism_path, url):
  function make_core (line 89) | def make_core(prism_path, components, minified):
  function make_theme (line 94) | def make_theme(prism_path, components, name, minified):
  function make_language (line 99) | def make_language(prism_path, components, name, minified):
  function make_languages (line 104) | def make_languages(prism_path, components, names, minified):
  function make_plugin (line 122) | def make_plugin(prism_path, components, name, minified):
  function make_plugins (line 127) | def make_plugins(prism_path, components, names, minified):
  function make_code (line 132) | def make_code(prism_path, url, minified):
  function join_code (line 155) | def join_code(kv_code):
  function write_code (line 166) | def write_code(kv_code, js_out, css_out):
  function parse_args (line 178) | def parse_args():
  function main (line 191) | def main():

FILE: scripts/deps-docker/shiftbase.py
  function main (line 7) | def main():

FILE: scripts/docker/base/patch/ffmpeg/libavcodec/aacps.c
  function hybrid_analysis (line 15) | static void hybrid_analysis(PSDSPContext *dsp, INTFLOAT out[91][32][2],
  function hybrid_synthesis (line 19) | static void hybrid_synthesis(PSDSPContext *dsp, INTFLOAT out[2][38][64],
  function decorrelation (line 22) | static void decorrelation(PSContext *ps, INTFLOAT (*out)[32][2], const I...
  function av_cold (line 26) | av_cold void AAC_RENAME(ff_ps_init)(void) {}

FILE: scripts/docker/base/patch/ffmpeg/libavcodec/aacsbr.c
  function make_bands (line 23) | static void make_bands(int16_t* bands, int start, int stop, int num_band...
  function sbr_dequant (line 25) | static void sbr_dequant(SpectralBandReplication *sbr, int id_aac) {}
  function sbr_hf_inverse_filter (line 27) | static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
  function sbr_chirp (line 31) | static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data) {}
  function sbr_gain_calc (line 33) | static void sbr_gain_calc(SpectralBandReplication *sbr,
  function sbr_hf_assemble (line 36) | static void sbr_hf_assemble(float Y1[38][64][2],

FILE: scripts/docker/base/patch/ffmpeg/libavcodec/aacsbr_fixed.c
  function fixed_log (line 25) | static int fixed_log(int x) {return 1;}
  function make_bands (line 27) | static void make_bands(int16_t* bands, int start, int stop, int num_band...
  function sbr_dequant (line 29) | static void sbr_dequant(SpectralBandReplication *sbr, int id_aac) {}
  function sbr_hf_inverse_filter (line 31) | static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
  function sbr_chirp (line 35) | static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data) {}
  function sbr_gain_calc (line 37) | static void sbr_gain_calc(SpectralBandReplication *sbr,
  function sbr_hf_assemble (line 40) | static void sbr_hf_assemble(int Y1[38][64][2],

FILE: scripts/fusefuzz.py
  function chk (line 14) | def chk(fsz, rsz, ofs0, shift, ofs, rf, vf):
  function main (line 34) | def main():

FILE: scripts/help2html.py
  function readclip (line 19) | def readclip():
  function cnv (line 36) | def cnv(src):
  function main (line 130) | def main():

FILE: scripts/pyinstaller/loader.py
  function confirm (line 42) | def confirm(rv):
  function ckck (line 54) | def ckck():
  function meicln (line 78) | def meicln(mod):
  function meichk (line 104) | def meichk():

FILE: scripts/sfx.py
  function eprint (line 57) | def eprint(*a, **ka):
  function msg (line 62) | def msg(*a, **ka):
  function testptn1 (line 72) | def testptn1():
  function testptn2 (line 83) | def testptn2():
  function testptn3 (line 97) | def testptn3():
  function testchk (line 110) | def testchk(cdata):
  function encode (line 164) | def encode(data, size, cksum, ver, ts):
  function makesfx (line 236) | def makesfx(tar_src, ver, ts):
  function u8 (line 245) | def u8(gen):
  function yieldfile (line 255) | def yieldfile(fn):
  function hashfile (line 262) | def hashfile(fn):
  function unpack (line 270) | def unpack():
  function get_payload (line 364) | def get_payload():
  function confirm (line 390) | def confirm(rv):
  function run (line 403) | def run(tmp, j2, ftp):
  function run_i (line 431) | def run_i(ld):
  function run_s (line 443) | def run_s(ld):
  function main (line 460) | def main():

FILE: scripts/speedtest-fs.py
  function get_spd (line 20) | def get_spd(nbyte, nfiles, nsec):
  class Inf (line 31) | class Inf(object):
    method __init__ (line 32) | def __init__(self, t0):
    method msg (line 49) | def msg(self, fn, n_read):
    method err (line 53) | def err(self, fn):
    method print_msgs (line 57) | def print_msgs(self):
    method report (line 72) | def report(self, fn, n_byte, n_sec):
    method done (line 78) | def done(self):
  function get_files (line 83) | def get_files(dir_path):
  function worker (line 95) | def worker(q, inf, read_sz):
  function sighandler (line 120) | def sighandler(signo, frame):
  function main (line 124) | def main():

FILE: scripts/strip_hints/a.py
  function pr (line 14) | def pr(m):
  function uh (line 19) | def uh(top):
  function uh1 (line 49) | def uh1(fp):
  function uh2 (line 57) | def uh2(fp):

FILE: scripts/test/ptrav.py
  function genlen (line 12) | def genlen(ubase, port, ntot, nth, wlen):
  function main (line 49) | def main():

FILE: scripts/test/race.py
  class Conn (line 11) | class Conn(object):
    method __init__ (line 12) | def __init__(self, ip, port):
    method get (line 16) | def get(self, vpath):
    method get_json (line 33) | def get_json(self, vpath):
  class CState (line 38) | class CState(threading.Thread):
    method __init__ (line 39) | def __init__(self, cs):
    method run (line 45) | def run(self):
  function allget (line 70) | def allget(cs, urls):
  function main (line 81) | def main():

FILE: scripts/test/smoketest.py
  class Cpp (line 16) | class Cpp(object):
    method __init__ (line 17) | def __init__(self, args):
    method _run (line 29) | def _run(self):
    method stop (line 32) | def stop(self, wait):
    method clean (line 39) | def clean(self):
    method await_idle (line 45) | def await_idle(self, ub, timeout):
  function tc1 (line 63) | def tc1(vflags):
  function run (line 219) | def run(tc, *a):
  function main (line 229) | def main():

FILE: scripts/tl.js
  function langmod (line 12) | function langmod() {

FILE: scripts/tl.py
  function generate_javascript (line 32) | def generate_javascript(lang3, native_name, tl_browser):
  function die (line 134) | def die(*a):
  function main (line 139) | def main():

FILE: scripts/uncomment.py
  function uncomment (line 17) | def uncomment(fpath):
  function main (line 83) | def main():

FILE: scripts/ziploader.py
  function msg (line 13) | def msg(*a, **ka):
  function confirm (line 21) | def confirm(rv):
  function run (line 34) | def run():
  function main (line 40) | def main():

FILE: setup.py
  class clean2 (line 44) | class clean2(Command):
    method initialize_options (line 48) | def initialize_options(self):
    method finalize_options (line 51) | def finalize_options(self):
    method run (line 54) | def run(self):

FILE: tests/ptrav.py
  function nolog (line 17) | def nolog(*a, **ka):
  function hdr (line 21) | def hdr(query):
  function curl (line 26) | def curl(args, asrv, url, binary=False):
  function genlen (line 36) | def genlen(ubase, ntot, nth, wlen):
  function main (line 66) | def main():

FILE: tests/run.py
  function rp (line 11) | def rp():

FILE: tests/test_cp.py
  class TestDedup (line 17) | class TestDedup(tu.TC):
    method setUp (line 18) | def setUp(self):
    method tearDown (line 21) | def tearDown(self):
    method reset (line 27) | def reset(self):
    method cinit (line 44) | def cinit(self):
    method test (line 53) | def test(self):
    method do_cp (line 88) | def do_cp(self, action):
    method propfind (line 99) | def propfind(self):
    method log (line 109) | def log(self, src, msg, c=0):

FILE: tests/test_dedup.py
  class TestDedup (line 18) | class TestDedup(tu.TC):
    method setUp (line 19) | def setUp(self):
    method tearDown (line 36) | def tearDown(self):
    method reset (line 42) | def reset(self):
    method cinit (line 50) | def cinit(self):
    method test_a (line 59) | def test_a(self):
    method test (line 100) | def test(self):
    method do_tc (line 142) | def do_tc(self, cm1, cm2, cm3, irm):
    method do_post (line 172) | def do_post(self, dn, fn, fi, first):
    method do_post_hs (line 178) | def do_post_hs(self, dn, fn, fi, first, replace=False):
    method do_post_data (line 193) | def do_post_data(self, dn, fn, fi, first, sfn, hs):
    method handshake (line 205) | def handshake(self, dn, fn, fi, replace=False):
    method put_chunk (line 218) | def put_chunk(self, dn, wark, chash, data):
    method curl (line 235) | def curl(self, url, binary=False, meth=None):
    method log (line 246) | def log(self, src, msg, c=0):

FILE: tests/test_dots.py
  function hdr (line 26) | def hdr(query, uname, extra=""):
  class TestDots (line 31) | class TestDots(unittest.TestCase):
    method __init__ (line 32) | def __init__(self, *a, **ka):
    method setUp (line 37) | def setUp(self):
    method tearDown (line 41) | def tearDown(self):
    method cinit (line 47) | def cinit(self):
    method test_dots (line 60) | def test_dots(self):
    method test_dk_fk (line 153) | def test_dk_fk(self):
    method tardir (line 371) | def tardir(self, url, uname):
    method tarsel (line 381) | def tarsel(self, url, uname, sel):
    method curl (line 392) | def curl(self, url, uname, binary=False, req=b""):
    method log (line 402) | def log(self, src, msg, c=0):

FILE: tests/test_dxml.py
  function _parse (line 14) | def _parse(txt):
  class TestDXML (line 22) | class TestDXML(unittest.TestCase):
    method test_qbe (line 23) | def test_qbe(self):
    method test_ent_file (line 32) | def test_ent_file(self):
    method test_ent_ext (line 45) | def test_ent_ext(self):
    method test_dtd (line 53) | def test_dtd(self):
    method test3 (line 64) | def test3(self):
    method test4 (line 81) | def test4(self):
    method test5 (line 125) | def test5(self):

FILE: tests/test_hooks.py
  function hdr (line 21) | def hdr(query):
  class TestHooks (line 26) | class TestHooks(tu.TC):
    method setUp (line 27) | def setUp(self):
    method tearDown (line 31) | def tearDown(self):
    method reset (line 35) | def reset(self):
    method cinit (line 43) | def cinit(self):
    method test (line 49) | def test(self):
    method test2 (line 81) | def test2(self):
    method makehook (line 116) | def makehook(self, hs):
    method put (line 120) | def put(self, url):
    method bup (line 130) | def bup(self, url):
    method curl (line 149) | def curl(self, url, binary=False):
    method log (line 158) | def log(self, src, msg, c=0):

FILE: tests/test_httpcli.py
  function hdr (line 21) | def hdr(query):
  class TestHttpCli (line 26) | class TestHttpCli(unittest.TestCase):
    method setUp (line 27) | def setUp(self):
    method tearDown (line 31) | def tearDown(self):
    method test (line 35) | def test(self):
    method can_rw (line 201) | def can_rw(self, fp):
    method in_dive (line 211) | def in_dive(self, top, fp):
    method put (line 227) | def put(self, url):
    method curl (line 237) | def curl(self, url, binary=False):
    method propfind (line 246) | def propfind(self, url, depth=1):
    method log (line 253) | def log(self, src, msg, c=0):

FILE: tests/test_idp.py
  class TestVFS (line 14) | class TestVFS(unittest.TestCase):
    method dump (line 15) | def dump(self, vfs):
    method log (line 18) | def log(self, src, msg, c=0):
    method nav (line 31) | def nav(self, au, vp):
    method assertAxs (line 34) | def assertAxs(self, axs, expected):
    method assertAxsAt (line 43) | def assertAxsAt(self, au, vp, expected):
    method assertNodes (line 47) | def assertNodes(self, vfs, expected):
    method assertNodesAt (line 51) | def assertNodesAt(self, au, vp, expected):
    method assertApEq (line 55) | def assertApEq(self, ap, rhs):
    method prep (line 61) | def prep(self):
    method test_1 (line 72) | def test_1(self):
    method test_2 (line 87) | def test_2(self):
    method test_3 (line 105) | def test_3(self):
    method test_4 (line 131) | def test_4(self):
    method test_5 (line 169) | def test_5(self):
    method test_6 (line 199) | def test_6(self):
    method test_7 (line 240) | def test_7(self):
    method test_8 (line 279) | def test_8(self):

FILE: tests/test_metrics.py
  function hdr (line 19) | def hdr(query):
  class TestMetrics (line 24) | class TestMetrics(tu.TC):
    method setUp (line 25) | def setUp(self):
    method tearDown (line 29) | def tearDown(self):
    method cinit (line 35) | def cinit(self):
    method test (line 51) | def test(self):
    method curl (line 97) | def curl(self, url, binary=False):
    method log (line 106) | def log(self, src, msg, c=0):

FILE: tests/test_mv.py
  class TestDedup (line 23) | class TestDedup(tu.TC):
    method setUp (line 24) | def setUp(self):
    method tearDown (line 27) | def tearDown(self):
    method reset (line 33) | def reset(self):
    method cinit (line 41) | def cinit(self):
    method test (line 50) | def test(self):
    method do_mv (line 126) | def do_mv(self, src, dst):
    method do_post (line 137) | def do_post(self, dn, fn, fi, first):
    method handshake (line 162) | def handshake(self, dn, fn, fi):
    method put_chunk (line 173) | def put_chunk(self, dn, wark, chash, data):
    method curl (line 190) | def curl(self, url, binary=False):
    method log (line 199) | def log(self, src, msg, c=0):

FILE: tests/test_shr.py
  class TestShr (line 20) | class TestShr(unittest.TestCase):
    method log (line 21) | def log(self, src, msg, c=0):
    method assertLD (line 33) | def assertLD(self, url, auth, els, edl):
    method setUp (line 56) | def setUp(self):
    method tearDown (line 77) | def tearDown(self):
    method cinit (line 81) | def cinit(self):
    method test1 (line 85) | def test1(self):
    method test2 (line 139) | def test2(self):
    method ls (line 196) | def ls(self, url: str, auth: bool):
    method curl (line 208) | def curl(self, url: str, binary=False):
    method post_json (line 217) | def post_json(self, url: str, data):

FILE: tests/test_utils.py
  class TestUtils (line 12) | class TestUtils(unittest.TestCase):
    method cmp (line 13) | def cmp(self, orig, t1, t2):
    method test_quotep (line 17) | def test_quotep(self):
    method test_unquote (line 26) | def test_unquote(self):

FILE: tests/test_vfs.py
  class TestVFS (line 17) | class TestVFS(unittest.TestCase):
    method setUp (line 18) | def setUp(self):
    method tearDown (line 21) | def tearDown(self):
    method dump (line 25) | def dump(self, vfs):
    method unfoo (line 28) | def unfoo(self, foo):
    method undot (line 34) | def undot(self, vfs, query, response):
    method ls (line 40) | def ls(self, vfs, vpath, uname):
    method log (line 52) | def log(self, src, msg, c=0):
    method assertAxs (line 55) | def assertAxs(self, dct, lst):
    method wipe_vfs (line 60) | def wipe_vfs(self, td):
    method test (line 77) | def test(self):

FILE: tests/test_webdav.py
  class TestHttpCli (line 103) | class TestHttpCli(TC):
    method setUp (line 104) | def setUp(self):
    method tearDown (line 108) | def tearDown(self):
    method test (line 113) | def test(self):
    method req (line 275) | def req(self, q):
    method log (line 282) | def log(self, src, msg, c=0):

FILE: tests/util.py
  function nah (line 26) | def nah(*a, **ka):
  function eprint (line 30) | def eprint(*a, **ka):
  function randbytes (line 46) | def randbytes(n):
  function runcmd (line 50) | def runcmd(argv):
  function chkcmd (line 58) | def chkcmd(argv):
  function get_ramdisk (line 66) | def get_ramdisk():
  function pfind2ls (line 128) | def pfind2ls(xml):
  class TC (line 132) | class TC(unittest.TestCase):
    method __init__ (line 133) | def __init__(self, *a, **ka):
    method assertStart (line 136) | def assertStart(self, member, container, msg=None):
  class Cfg (line 142) | class Cfg(Namespace):
    method __init__ (line 143) | def __init__(self, a=None, v=None, c=None, **ka0):
  class NullBroker (line 239) | class NullBroker(object):
    method __init__ (line 240) | def __init__(self, args, asrv):
    method say (line 244) | def say(self, *args):
    method ask (line 247) | def ask(self, *args):
  class VSock (line 251) | class VSock(object):
    method __init__ (line 252) | def __init__(self, buf):
    method recv (line 258) | def recv(self, sz):
    method send (line 263) | def send(self, buf):
    method getsockname (line 267) | def getsockname(self):
    method settimeout (line 270) | def settimeout(self, a):
  class VHub (line 274) | class VHub(object):
    method __init__ (line 275) | def __init__(self, args, asrv, log):
    method reload (line 282) | def reload(self, a, b):
  class VBrokerThr (line 286) | class VBrokerThr(BrokerThr):
    method __init__ (line 287) | def __init__(self, hub):
  class VHttpSrv (line 294) | class VHttpSrv(object):
    method __init__ (line 295) | def __init__(self, args, asrv, log):
    method cachebuster (line 321) | def cachebuster(self):
    method get_u2idx (line 324) | def get_u2idx(self):
    method shutdown (line 328) | def shutdown(self):
  class VHttpSrvUp2k (line 333) | class VHttpSrvUp2k(VHttpSrv):
    method __init__ (line 334) | def __init__(self, args, asrv, log):
    method shutdown (line 339) | def shutdown(self):
  class VHttpConn (line 345) | class VHttpConn(object):
    method __init__ (line 346) | def __init__(self, args, asrv, log, buf, use_up2k=False):
    method setbuf (line 378) | def setbuf(self, buf):
    method shutdown (line 383) | def shutdown(self):