Something went wrong. Try again.
Self-hosted file management and sharing system, supports multiple storage providers. forked from tdvorak.tngl.sh/cloudreve
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598#!/usr/bin/env python3"""Local Cloudreve backend for Android UI work.
Builds the server from this checkout, runs it on 127.0.0.1:5212 (reachablefrom the emulator as http://10.0.2.2:5212), registers a dev user and fillsthe drive with realistic sample data: photos, PDFs, videos, audio, archives,source files and one big blob for transfer-progress testing.
./devserver.py all build + start + seed + push ./devserver.py build compile ./cloudreve into .data/ ./devserver.py start run the server in the background ./devserver.py stop ./devserver.py status ./devserver.py seed register DEV_USER and upload the sample tree ./devserver.py push copy the sample files to the emulator's Downloads ./devserver.py login install the debug APK and sign in on the emulator via adb ./devserver.py reset stop and wipe the database + uploaded blobs
Everything lives under android/dev/.data/ (gitignored). Stdlib only."""
from __future__ import annotations
import ioimport jsonimport mathimport osimport randomimport shutilimport signalimport structimport subprocessimport sysimport timeimport urllib.errorimport urllib.parseimport urllib.requestimport waveimport zipfilefrom pathlib import Path
DEV_DIR = Path(__file__).resolve().parentREPO = DEV_DIR.parent.parentDATA = DEV_DIR / ".data"BIN = DATA / "cloudreve"SEED = DATA / "seed"PID_FILE = DATA / "server.pid"LOG_FILE = DATA / "server.log"
LISTEN = "127.0.0.1:5212"BASE = f"http://{LISTEN}"EMULATOR_URL = "http://10.0.2.2:5212"DEV_USER = "dev@example.com"DEV_PASSWORD = "cloudreve-dev"DEVICE_DIR = "/sdcard/Download/cloudreve-seed"
PICSUM = "https://picsum.photos/seed/{seed}/{w}/{h}.jpg"VIDEOS = { "Big_Buck_Bunny_360_10s_1MB.mp4": "https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/360/Big_Buck_Bunny_360_10s_1MB.mp4", "Big_Buck_Bunny_720_10s_5MB.mp4": "https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/720/Big_Buck_Bunny_720_10s_5MB.mp4", "Jellyfish_360_10s_2MB.mp4": "https://test-videos.co.uk/vids/jellyfish/mp4/h264/360/Jellyfish_360_10s_2MB.mp4",}
# --------------------------------------------------------------------------- ## server lifecycle# --------------------------------------------------------------------------- #
def go_binary() -> str: """Prefer the mise-managed Go the repo pins; fall back to PATH.""" try: out = subprocess.run( ["mise", "which", "go"], cwd=REPO, capture_output=True, text=True, check=True ).stdout.strip() if out: return out except (OSError, subprocess.CalledProcessError): pass return shutil.which("go") or sys.exit("go not found (install via mise or brew)")
def ensure_assets_zip() -> None: """statics.go embeds assets.zip; the API works fine with a stub.""" target = REPO / "application" / "statics" / "assets.zip" if target.exists(): return print("assets.zip missing; writing a stub (API-only, no web UI)") with zipfile.ZipFile(target, "w") as z: z.writestr("version.json", json.dumps({"name": "cloudreve-frontend", "version": "dev"})) z.writestr("index.html", "<!doctype html><title>Cloudreve dev</title>API only.")
def cmd_build() -> None: DATA.mkdir(parents=True, exist_ok=True) ensure_assets_zip() print("building server...") subprocess.run([go_binary(), "build", "-o", str(BIN), "."], cwd=REPO, check=True) print(f"built {BIN}")
def server_pid() -> int | None: if not PID_FILE.exists(): return None pid = int(PID_FILE.read_text().strip() or 0) try: os.kill(pid, 0) except (OSError, ProcessLookupError): PID_FILE.unlink(missing_ok=True) return None return pid
def api_up() -> bool: try: urllib.request.urlopen(f"{BASE}/api/v4/site/config/basic", timeout=2).read() return True except (urllib.error.URLError, OSError): return False
def cmd_start() -> None: if server_pid(): print(f"already running (pid {server_pid()})") return if api_up(): sys.exit(f"something already answers on {BASE} but is not tracked by {PID_FILE}; " "stop it first (pgrep -fl 'cloudreve server')") if not BIN.exists(): cmd_build() env = dict(os.environ) # Bind to loopback only: the emulator reaches it through 10.0.2.2. env["CR_CONF_System__Listen"] = LISTEN # Download/thumbnail URLs are built from siteURL; the emulator must be able # to reach them, so point it at the host alias. Only applied on first init. env["CR_SETTING_DEFAULT_siteURL"] = EMULATOR_URL # Optional generators picked up on first database init. if shutil.which("ffmpeg"): env["CR_SETTING_DEFAULT_thumb_ffmpeg_enabled"] = "1" if shutil.which("vips"): env["CR_SETTING_DEFAULT_thumb_vips_enabled"] = "1" if shutil.which("soffice"): env["CR_SETTING_DEFAULT_thumb_libreoffice_enabled"] = "1" log = open(LOG_FILE, "ab") proc = subprocess.Popen( [str(BIN), "server", "-w"], cwd=DATA, env=env, stdout=log, stderr=subprocess.STDOUT, start_new_session=True, ) PID_FILE.write_text(str(proc.pid)) for _ in range(60): if api_up(): print(f"server up at {BASE} (pid {proc.pid}); emulator: {EMULATOR_URL}") return if proc.poll() is not None: sys.exit(f"server exited early, see {LOG_FILE}") time.sleep(0.5) sys.exit(f"server did not answer in time, see {LOG_FILE}")
def cmd_stop() -> None: pid = server_pid() if not pid: print("not running") return os.kill(pid, signal.SIGTERM) for _ in range(40): if not server_pid(): break time.sleep(0.25) else: os.kill(pid, signal.SIGKILL) PID_FILE.unlink(missing_ok=True) print("stopped")
def cmd_status() -> None: pid = server_pid() print(f"pid: {pid or '-'} api: {'up' if api_up() else 'down'} url: {BASE}") print(f"emulator url: {EMULATOR_URL} user: {DEV_USER} password: {DEV_PASSWORD}")
def cmd_reset() -> None: cmd_stop() for name in ("data", "conf.ini"): p = DATA / name if p.is_dir(): shutil.rmtree(p) elif p.exists(): p.unlink() print("database and uploads wiped (binary and seed cache kept)")
# --------------------------------------------------------------------------- ## API client# --------------------------------------------------------------------------- #
class Api: def __init__(self) -> None: self.token: str | None = None
def call(self, method: str, path: str, body=None, raw: bytes | None = None, content_type: str = "application/json"): url = path if path.startswith("http") else BASE + path data = raw if raw is not None else (json.dumps(body).encode() if body is not None else None) req = urllib.request.Request(url, data=data, method=method) req.add_header("Content-Type", content_type) if self.token: req.add_header("Authorization", f"Bearer {self.token}") try: with urllib.request.urlopen(req, timeout=120) as resp: text = resp.read() except urllib.error.HTTPError as e: text = e.read() raise RuntimeError(f"{method} {path} -> HTTP {e.code}: {text[:300]!r}") from None if not text: return None payload = json.loads(text) if payload.get("code", 0) != 0: raise RuntimeError(f"{method} {path} -> {payload.get('code')}: {payload.get('msg')}") return payload.get("data")
def register_or_login(self) -> None: try: self.call("POST", "/api/v4/user", {"email": DEV_USER, "password": DEV_PASSWORD}) print(f"registered {DEV_USER}") except RuntimeError as e: if "40032" not in str(e): # 40032: email already in use raise data = self.call("POST", "/api/v4/session/token", {"email": DEV_USER, "password": DEV_PASSWORD}) self.token = data["token"]["access_token"]
def mkdir(self, uri: str) -> None: try: self.call("POST", "/api/v4/file/create", {"uri": uri, "type": "folder"}) except RuntimeError as e: if "exist" not in str(e).lower() and "40004" not in str(e): raise
def list(self, uri: str) -> list[dict]: q = urllib.parse.urlencode({"uri": uri, "page_size": 500}) return self.call("GET", f"/api/v4/file?{q}")["files"]
def upload(self, local: Path, parent_uri: str, mime: str) -> None: size = local.stat().st_size session = self.call("PUT", "/api/v4/file/upload", { "uri": f"{parent_uri}/{urllib.parse.quote(local.name)}", "size": size, "last_modified": int(local.stat().st_mtime * 1000), "mime_type": mime, }) if session.get("rapid_uploaded"): return chunk = session.get("chunk_size") or max(size, 1) urls = session.get("upload_urls") or [] with local.open("rb") as f: index = 0 while True: buf = f.read(chunk) if not buf and index > 0: break target = urls[index] if index < len(urls) else \ f"{BASE}/api/v4/file/upload/{session['session_id']}/{index}" method = "POST" if "/file/upload/" in target else "PUT" self.call(method, target, raw=buf, content_type=mime) index += 1 if len(buf) < chunk: break if session.get("completeURL"): self.call("POST", session["completeURL"])
# --------------------------------------------------------------------------- ## sample data generation# --------------------------------------------------------------------------- #
def fetch(url: str, dest: Path) -> None: if dest.exists() and dest.stat().st_size > 0: return print(f" download {dest.name}") req = urllib.request.Request(url, headers={"User-Agent": "cloudreve-devserver"}) with urllib.request.urlopen(req, timeout=60) as resp, dest.open("wb") as out: shutil.copyfileobj(resp, out)
def write_pdf(dest: Path, title: str, pages: list[list[str]]) -> None: """Minimal valid multi-page PDF with Helvetica text, no dependencies.""" if dest.exists(): return objects: list[bytes] = []
def add(obj: bytes) -> int: objects.append(obj) return len(objects)
font = add(b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>") page_ids: list[int] = [] pages_id = len(objects) + 1 + 2 * len(pages) # reserved after content+page objs for i, lines in enumerate(pages): body = [b"BT /F1 20 Tf 60 760 Td (" + title.encode("latin-1", "replace") + b") Tj ET"] y = 720 for line in lines: esc = line.replace("\\", "\\\\").replace("(", "\\(").replace(")", "\\)") body.append(f"BT /F1 11 Tf 60 {y} Td ({esc}) Tj ET".encode("latin-1", "replace")) y -= 16 body.append(f"BT /F1 9 Tf 60 40 Td (Page {i + 1} of {len(pages)}) Tj ET".encode()) stream = b"\n".join(body) content = add(b"<< /Length " + str(len(stream)).encode() + b" >>\nstream\n" + stream + b"\nendstream") page = add( f"<< /Type /Page /Parent {pages_id} 0 R /MediaBox [0 0 595 842] " f"/Contents {content} 0 R /Resources << /Font << /F1 {font} 0 R >> >> >>".encode() ) page_ids.append(page) kids = " ".join(f"{p} 0 R" for p in page_ids) assert add(f"<< /Type /Pages /Kids [{kids}] /Count {len(page_ids)} >>".encode()) == pages_id catalog = add(f"<< /Type /Catalog /Pages {pages_id} 0 R >>".encode())
out = io.BytesIO() out.write(b"%PDF-1.4\n") offsets = [] for n, obj in enumerate(objects, 1): offsets.append(out.tell()) out.write(f"{n} 0 obj\n".encode() + obj + b"\nendobj\n") xref = out.tell() out.write(f"xref\n0 {len(objects) + 1}\n0000000000 65535 f \n".encode()) for off in offsets: out.write(f"{off:010d} 00000 n \n".encode()) out.write(f"trailer\n<< /Size {len(objects) + 1} /Root {catalog} 0 R >>\nstartxref\n{xref}\n%%EOF\n".encode()) dest.write_bytes(out.getvalue())
def write_wav(dest: Path, freqs: list[float], seconds: float = 20.0) -> None: if dest.exists(): return rate = 44100 n = int(rate * seconds) frames = bytearray() for i in range(n): t = i / rate env = min(1.0, t * 4) * min(1.0, (seconds - t) * 4) sample = sum(math.sin(2 * math.pi * f * t) for f in freqs) / len(freqs) frames += struct.pack("<h", int(sample * env * 12000)) with wave.open(str(dest), "wb") as w: w.setnchannels(1) w.setsampwidth(2) w.setframerate(rate) w.writeframes(bytes(frames))
def write_blob(dest: Path, size_mb: int) -> None: if dest.exists() and dest.stat().st_size == size_mb * 1024 * 1024: return rng = random.Random(size_mb) with dest.open("wb") as f: for _ in range(size_mb): f.write(rng.randbytes(1024 * 1024))
def write_text(dest: Path, text: str) -> None: if not dest.exists(): dest.write_text(text)
LOREM = ("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor " "incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud " "exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.").split(" ")
def paragraph(rng: random.Random, words: int = 70) -> list[str]: text, line, lines = [], [], [] for _ in range(words): line.append(rng.choice(LOREM)) if len(" ".join(line)) > 80: lines.append(" ".join(line)) line = [] if line: lines.append(" ".join(line)) return lines
def build_seed_tree() -> Path: """Returns the root of the local sample tree; mirrors the remote layout.""" rng = random.Random(7) root = SEED print("preparing sample files...")
trip = root / "Photos" / "2025 Summer Trip" trip.mkdir(parents=True, exist_ok=True) for i in range(10): fetch(PICSUM.format(seed=f"trip{i}", w=1600, h=1067), trip / f"IMG_202507{10 + i:02d}_{rng.randint(80000, 195959):06d}.jpg") shots = root / "Photos" / "Screenshots" shots.mkdir(exist_ok=True) for i in range(4): fetch(PICSUM.format(seed=f"shot{i}", w=1080, h=2400), shots / f"Screenshot_2025110{i + 1}-{rng.randint(10, 23)}{rng.randint(10, 59)}{rng.randint(10, 59)}.jpg") wall = root / "Photos" / "Wallpapers" wall.mkdir(exist_ok=True) for i, name in enumerate(["mountains", "ocean", "forest", "city-night", "desert"]): fetch(PICSUM.format(seed=f"wall{i}", w=2560, h=1440), wall / f"{name}.jpg")
pay = root / "Documents" / "Payslips" pay.mkdir(parents=True, exist_ok=True) for m in range(1, 11): write_pdf(pay / f"Payslip_2025-{m:02d}.pdf", f"Payslip 2025-{m:02d}", [ ["Employee: Dev User", "Period: 2025-%02d" % m, "", "Gross salary ............ 8,250.00", "Pension ................... -412.50", "Income tax .............. -1,980.00", "Net paid ................ 5,857.50"], ]) docs = root / "Documents" write_pdf(docs / "Resume.pdf", "Dev User - Resume", [paragraph(rng, 160), paragraph(rng, 140)]) write_pdf(docs / "Lease Agreement 2025.pdf", "Lease Agreement", [paragraph(rng, 200) for _ in range(6)]) write_pdf(docs / "Boarding pass - ZRH to DEL.pdf", "Boarding pass", [["Passenger: Dev User", "Flight LX 146", "Seat 23A", "Gate B41", "Boarding 09:40"]]) write_text(docs / "Notes.md", "# Notes\n\n" + "\n\n".join(" ".join(paragraph(rng, 60)) for _ in range(5)) + "\n") write_text(docs / "Budget 2025.csv", "month,rent,groceries,transport,savings\n" + "\n".join( f"2025-{m:02d},1850,{rng.randint(380, 560)},{rng.randint(60, 140)},{rng.randint(900, 2200)}" for m in range(1, 13)) + "\n") write_text(docs / "config.json", json.dumps({"theme": "dark", "language": "en", "sync": {"wifiOnly": True, "folders": ["Photos", "Documents"]}}, indent=2) + "\n") write_text(docs / "shopping-list.txt", "milk\noats\ncoffee beans\ntoothpaste\nbatteries (AA)\n")
vids = root / "Videos" vids.mkdir(exist_ok=True) for name, url in VIDEOS.items(): try: fetch(url, vids / name) except (urllib.error.URLError, OSError) as e: print(f" skip {name}: {e}")
music = root / "Music" music.mkdir(exist_ok=True) write_wav(music / "A440 reference tone.wav", [440.0], 8) write_wav(music / "C major chord.wav", [261.63, 329.63, 392.0], 12) write_wav(music / "Ambient drone.wav", [110.0, 165.0, 220.5], 20)
code = root / "Code" / "basement" code.mkdir(parents=True, exist_ok=True) write_text(code / "main.rs", 'fn main() {\n println!("hello from basement");\n}\n') write_text(code / "Cargo.toml", '[package]\nname = "basement"\nversion = "0.1.0"\nedition = "2024"\n') write_text(code / "README.md", "# basement\n\nPersonal data management server.\n") write_text(root / "Code" / "deploy.py", "#!/usr/bin/env python3\nprint('deploy')\n")
arch = root / "Archives" arch.mkdir(exist_ok=True) zpath = arch / "documents-backup-2025-10.zip" if not zpath.exists(): with zipfile.ZipFile(zpath, "w", zipfile.ZIP_DEFLATED) as z: for p in docs.rglob("*"): if p.is_file(): z.write(p, p.relative_to(docs))
dl = root / "Downloads" dl.mkdir(exist_ok=True) write_blob(dl / "dataset-2025.bin", 60) write_blob(dl / "firmware-update.img", 25)
(root / "Empty folder").mkdir(exist_ok=True) deep = root / "Projects" / "2025" / "Q4" / "Android UX" deep.mkdir(parents=True, exist_ok=True) write_text(deep / "plan.md", "# Android UX\n\n- thumbnails\n- upload progress\n- previews\n")
# A long name and a unicode name, both common in real drives. write_text(root / "Documents" / "Very long file name that will certainly need truncation in a list row because it keeps going.txt", "long\n") write_text(root / "Documents" / "Rechnung Ökostrom März 2025 – Übersicht.txt", "umlauts\n") return root
MIME = { ".jpg": "image/jpeg", ".png": "image/png", ".pdf": "application/pdf", ".md": "text/markdown", ".txt": "text/plain", ".csv": "text/csv", ".json": "application/json", ".mp4": "video/mp4", ".wav": "audio/wav", ".zip": "application/zip", ".rs": "text/x-rust", ".toml": "text/plain", ".py": "text/x-python", ".bin": "application/octet-stream", ".img": "application/octet-stream",}
def cmd_seed() -> None: if not api_up(): cmd_start() root = build_seed_tree() api = Api() api.register_or_login()
print("uploading to the dev drive...") existing: dict[str, set[str]] = {}
def names_in(uri: str) -> set[str]: if uri not in existing: existing[uri] = {f["name"] for f in api.list(uri)} return existing[uri]
uploaded = skipped = 0 for dirpath, dirnames, filenames in os.walk(root): dirnames.sort() rel = Path(dirpath).relative_to(root) parent = "cloudreve://my" + ("" if rel == Path(".") else "/" + "/".join(urllib.parse.quote(p) for p in rel.parts)) if rel != Path("."): api.mkdir(parent) have = names_in(parent) for name in sorted(filenames): if name in have: skipped += 1 continue local = Path(dirpath) / name print(f" {rel / name} ({local.stat().st_size // 1024} kB)") api.upload(local, parent, MIME.get(local.suffix.lower(), "application/octet-stream")) uploaded += 1 print(f"done: {uploaded} uploaded, {skipped} already present") print(f"sign in on the emulator with {EMULATOR_URL} {DEV_USER} {DEV_PASSWORD}")
def cmd_push() -> None: """Copy the sample files to the emulator so uploads can be tested from the app.""" adb = shutil.which("adb") or str(Path.home() / "Library/Android/sdk/platform-tools/adb") root = build_seed_tree() subprocess.run([adb, "shell", "mkdir", "-p", DEVICE_DIR], check=True) for sub in ("Photos/2025 Summer Trip", "Documents", "Videos", "Downloads"): subprocess.run([adb, "push", str(root / sub), DEVICE_DIR + "/"], check=True) # Make the pushed media visible to the picker's gallery view. subprocess.run([adb, "shell", "cmd", "media", "scan", DEVICE_DIR], check=False) print(f"pushed to {DEVICE_DIR}")
def cmd_login() -> None: """Install the debug APK, wipe its data and sign in to the dev backend via adb.""" import re adb = shutil.which("adb") or str(Path.home() / "Library/Android/sdk/platform-tools/adb") apk = DEV_DIR.parent / "app/build/outputs/apk/debug/app-debug.apk" pkg = "com.tdvorak.cloudreve"
def sh(*args, **kw): return subprocess.run([adb, *args], check=True, capture_output=True, text=True, **kw)
if apk.exists(): sh("install", "-r", str(apk)) sh("shell", "pm", "clear", pkg) sh("shell", "am", "start", "-n", f"{pkg}/org.cloudreve.android.MainActivity") node = re.compile(r'<node[^>]*?class="([^"]+)"[^>]*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"')
def controls() -> tuple[list[tuple[int, int]], list[tuple[int, int]]]: """EditText centres top-to-bottom, and full-width Button centres top-to-bottom.""" dump = sh("exec-out", "uiautomator", "dump", "/dev/tty").stdout fields, wide = [], [] for cls, l, t, r, b in node.findall(dump): centre = ((int(l) + int(r)) // 2, (int(t) + int(b)) // 2) if cls.endswith("EditText"): fields.append(centre) # Compose buttons expose no text; the password eye toggle is small, # Sign in is the topmost full-width button. elif cls.endswith("Button") and int(r) - int(l) > 600: wide.append(centre) return sorted(fields, key=lambda c: c[1]), sorted(wide, key=lambda c: c[1])
for _ in range(20): # the form takes a moment to appear after a cold start time.sleep(1) fields, wide = controls() if len(fields) >= 3 and wide: break else: sys.exit("login form not found on screen; is the app showing the login screen?")
# The form moves up when the soft keyboard opens (imePadding), so re-read # positions before every tap instead of trusting the first dump. for i, text in enumerate((EMULATOR_URL, DEV_USER, DEV_PASSWORD)): fields, _ = controls() x, y = fields[i] sh("shell", "input", "tap", str(x), str(y)) time.sleep(0.8) sh("shell", "input", "keyevent", "KEYCODE_MOVE_END") sh("shell", "input", "keyevent", *(["KEYCODE_DEL"] * 40)) sh("shell", "input", "text", text) time.sleep(0.3) if "mInputShown=true" in sh("shell", "dumpsys", "input_method").stdout: sh("shell", "input", "keyevent", "KEYCODE_BACK") time.sleep(1.5) _, wide = controls() sh("shell", "input", "tap", str(wide[0][0]), str(wide[0][1])) print("signed in on the emulator")
COMMANDS = { "build": cmd_build, "start": cmd_start, "stop": cmd_stop, "status": cmd_status, "seed": cmd_seed, "push": cmd_push, "reset": cmd_reset, "login": cmd_login,}
def main(argv: list[str]) -> None: if len(argv) != 2 or argv[1] not in COMMANDS | {"all": None}: sys.exit(__doc__) if argv[1] == "all": cmd_build() cmd_start() cmd_seed() cmd_push() return COMMANDS[argv[1]]()
if __name__ == "__main__": main(sys.argv)