zettcode-im 0.4.2__py3-none-any.whl

zettcode/im/weixin/cli.py

@@ -0,0 +1,374 @@
+"""``zettcode-weixin``: log in by scanning, then leave a background process to answer the chat.
+
+The command is a handover. ``zettcode-weixin`` starts a login, draws the QR code in the terminal, waits for the
+phone, writes the handshake away, and starts a process that owns the connection from then on. It then prints
+where that process is and exits, because a QR code and a running agent do not belong in the same window: the
+reader scans and closes the terminal, and the agent keeps answering.
+
+Running it again is how a login is replaced. A code is only good for the login it started, so the old process is
+stopped first and a new one takes over — the same daemon and the same conversation, a new connection to WeChat.
+
+A message may carry pictures: they travel with the text to the daemon, which puts them in the same prompt. The
+answer is text, because the platform's send takes text — an agent that writes a file says where it wrote it.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import contextlib
+import signal
+import sys
+from pathlib import Path
+
+from zettcode.version import __version__
+
+from . import qr
+from .worker import Worker, command
+
+#: Where the login, the cursor and the lock live when ``--state-dir`` is not given.
+DEFAULT_DIR = Path.home() / ".zettcode" / "im" / "weixin"
+
+#: Seconds to wait for the phone to scan, and seconds between looks at the login.
+LOGIN_TIMEOUT = 300.0
+POLL = 2.0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Return the parser: the four things a bridge does, and the settings they share."""
+    parser = argparse.ArgumentParser(
+        prog="zettcode-weixin",
+        description=(
+            "Drive one ZettCode daemon from a personal WeChat conversation. With no command it logs in: a QR "
+            "code to scan, then a background process that answers the chat, pictures included."
+        ),
+    )
+    parser.add_argument("--version", action="version", version=f"zettcode-weixin {__version__}")
+    commands = parser.add_subparsers(dest="command")
+    for name, help_line in (
+        ("login", "scan a QR code and start the background process (the default)"),
+        ("run", "run the bridge in this terminal (what the background process does)"),
+        ("status", "say whether a bridge is running and what it is doing"),
+        ("stop", "stop the background process"),
+        ("logs", "print the end of the background process's log"),
+    ):
+        sub = commands.add_parser(name, help=help_line, description=help_line)
+        _common(sub, login=name == "login", run=name == "run")
+        if name == "login":
+            sub.add_argument(
+                "--login-timeout",
+                type=float,
+                default=LOGIN_TIMEOUT,
+                help=f"seconds to wait for the scan (default: {int(LOGIN_TIMEOUT)})",
+            )
+        if name == "logs":
+            sub.add_argument("-n", "--lines", type=int, default=40, help="how many lines to print (default: 40)")
+    return parser
+
+
+def _common(sub: argparse.ArgumentParser, *, login: bool, run: bool) -> None:
+    """Add the settings a login writes and a run reads."""
+    sub.add_argument(
+        "--state-dir", type=Path, default=DEFAULT_DIR, help=f"where the bridge keeps itself (default: {DEFAULT_DIR})"
+    )
+    if login:
+        sub.add_argument(
+            "-w",
+            "--workspace",
+            type=Path,
+            default=None,
+            help="directory the agent works in (default: the one already stored, or the current directory)",
+        )
+        sub.add_argument("--model", default=None, help="the model the daemon runs on (default: the one already stored)")
+        sub.add_argument("--effort", default=None, help="the reasoning level (default: the one already stored)")
+        sub.add_argument(
+            "--permission",
+            choices=("deny", "safe", "full"),
+            default=None,
+            help="the daemon's shell level (default: the one already stored, or safe)",
+        )
+        sub.add_argument(
+            "--allow",
+            action="append",
+            default=None,
+            help="a sender id allowed to drive the agent, replacing the stored list; repeatable",
+        )
+        sub.add_argument(
+            "--allow-all",
+            action="store_true",
+            default=None,
+            help="let anyone who can message the bot drive the agent (it has a shell and this machine's files)",
+        )
+    if run:
+        sub.add_argument(
+            "--turn-timeout", type=float, default=600.0, help="seconds to wait for one answer (default: 600)"
+        )
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Parse the command line and do what it says; return the exit status."""
+    arguments = build_parser().parse_args(argv)
+    if arguments.command is None:
+        # No command: the shared flags still apply, so parse them for the login the reader meant.
+        arguments = build_parser().parse_args(["login", *(sys.argv[1:] if argv is None else argv)])
+    state_dir: Path = arguments.state_dir.expanduser()
+    if arguments.command == "login":
+        return asyncio.run(_login(arguments, state_dir))
+    if arguments.command == "run":
+        return asyncio.run(_run(arguments, state_dir))
+    if arguments.command == "status":
+        return _status(state_dir)
+    if arguments.command == "stop":
+        print(Worker(state_dir).stop())
+        return 0
+    if arguments.command == "logs":
+        text = Worker(state_dir).tail(arguments.lines)
+        print(text or f"nothing has been written to {Worker(state_dir).log} yet")
+        return 0
+    raise AssertionError(f"unknown command {arguments.command!r}")
+
+
+# -- login ---------------------------------------------------------------------------------------------
+async def _login(arguments: argparse.Namespace, state_dir: Path) -> int:
+    """Draw the QR code, wait for the scan, write the state, and start the background process."""
+    from agim.models import LoginStatus  # type: ignore[import-untyped]
+    from agim.wechat.client import WeChatClient  # type: ignore[import-untyped]
+
+    from ..state import BridgeState
+
+    state_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+    worker = Worker(state_dir)
+    # The running bridge stays up while the code is on screen: a scan that fails, or a reader who walks away,
+    # must not cost the bridge they already had. Nothing is written until the login has finished, so the old
+    # process keeps working on the state it started with.
+    state = BridgeState.load(state_dir / "state.json")
+    client = WeChatClient()
+    state_now = None
+    try:
+        handshake = await client.login()
+        print("Scan this with WeChat (the code is only good for this login):\n")
+        print(qr.show(handshake.qr_content))
+        if handshake.qr_url:
+            print(f"or open {handshake.qr_url}\n")
+        said: str = ""
+        verify: str | None = None
+        deadline = asyncio.get_running_loop().time() + max(1.0, arguments.login_timeout)
+        while asyncio.get_running_loop().time() < deadline:
+            state_now = await client.is_login(handshake, verify_code=verify)
+            status = state_now.status
+            if status == LoginStatus.CONNECTED:
+                break
+            if status in (LoginStatus.FAILED, LoginStatus.EXPIRED):
+                print(f"\nthe login did not finish: {state_now.message}")
+                return 2
+            if status == LoginStatus.SCANNED and said != "scanned":
+                said = "scanned"
+                print("\nscanned \u2014 confirm the login on your phone")
+            elif status == LoginStatus.VERIFY_REQUIRED and verify is None:
+                print(f"\n{state_now.message}")
+                verify = input("pairing code: ").strip() or None
+            await asyncio.sleep(POLL)
+        else:
+            print(f"\nnothing was scanned in {int(arguments.login_timeout)} seconds; run the command again")
+            return 2
+    finally:
+        await client.aclose()
+
+    credentials = state_now.credentials if state_now is not None else None
+    state.handshake = handshake.model_dump(mode="json")
+    state.credentials = credentials.model_dump(mode="json") if credentials is not None else {}
+    # A new login is a new connection: the cursor, the reply contexts and the answered ids belong to the old one —
+    # the platform numbers messages from the start again, so an id kept across a login can name a new message.
+    # The session stays, so the conversation and its history carry over.
+    state.cursor = ""
+    state.chats.clear()
+    state.seen.clear()
+    # A login renews the connection; the settings are what the reader decided and outlive it. A flag replaces its
+    # setting, and a flag that was not given leaves the stored one alone — a re-scan that forgot `--allow` used to
+    # wipe the allow-list and turn every message into a refusal.
+    if arguments.workspace is not None:
+        state.workspace = str(Path(arguments.workspace).expanduser().resolve())
+    elif not state.workspace:
+        state.workspace = str(Path.cwd())
+    if arguments.model is not None:
+        state.model = arguments.model
+    if arguments.effort is not None:
+        state.effort = arguments.effort
+    if arguments.permission is not None:
+        state.permission = arguments.permission
+    elif not state.permission:
+        state.permission = "safe"
+    if arguments.allow is not None:
+        state.allow = list(arguments.allow)
+    if arguments.allow_all is not None:
+        state.allow_all = bool(arguments.allow_all)
+    if not state.token():
+        # A login without a token is a bridge that cannot send or receive, and a background process that says
+        # nothing about it. Better to say so here, where the reader is still watching the phone.
+        print("the login finished, but WeChat handed back no bot token. Nothing was started; run the command again")
+        return 3
+
+    # Only now is the old process stopped, and it is stopped before the new state is written: one that is still
+    # running keeps its own copy and would write that back over the new token at its next message.
+    if worker.running():
+        print(worker.stop(), "\u2014 the new login replaces it")
+        if worker.running():
+            print("the old bridge did not stop, so the new login was not saved. Stop it by hand and run again.")
+            return 3
+    state.save()
+    try:
+        pid = worker.start(command("--state-dir", str(state_dir)))
+    except RuntimeError as error:
+        print(f"the login was saved, but the background process did not start: {error}")
+        return 3
+    print(f"\nlogged in. The bridge is running (pid {pid}) and will answer messages as they come.")
+    print(f"  log:    {worker.log}")
+    print(f"  stop:   zettcode-weixin stop --state-dir {state_dir}")
+    if not state.allow and not state.allow_all:
+        print("  note:   no sender is allowed yet \u2014 each message is refused and names the id to allow")
+    elif state.allow_all:
+        print("  allows: anyone who can message the bot")
+    else:
+        print(f"  allows: {', '.join(state.allow)}")
+    return 0
+
+
+# -- run -----------------------------------------------------------------------------------------------
+async def _run(arguments: argparse.Namespace, state_dir: Path) -> int:
+    """Run the bridge here, which is what the background process does."""
+    from agim.models import LoginHandshake, LoginStatus
+    from agim.wechat.client import WeChatClient
+
+    from zettcode.filelock import SingletonLock
+
+    from ..bridge import Bridge, BridgeSettings
+    from ..guard import DaemonGuard
+    from ..link import SessionLink
+    from ..state import BridgeState
+
+    state = BridgeState.load(state_dir / "state.json")
+    if not state.logged_in:
+        print(f"no login in {state_dir}: run `zettcode-weixin` first")
+        return 2
+    client = WeChatClient(token=state.token())
+    link = SessionLink(
+        session_id=_bridge_id(state_dir),
+        handle="weixin",
+        workspace=state.workspace,
+        timeout=arguments.turn_timeout,
+    )
+    lock: SingletonLock | None = None
+    try:
+        # The stored handshake is the *login* handshake, and it expires once the code has been scanned — the token
+        # it produced lives on. So this is a hint, not a gate: the poll below is what proves the token works.
+        try:
+            handshake = LoginHandshake.model_validate(state.handshake)
+            login = await client.is_login(handshake)
+        except Exception as error:  # noqa: BLE001 - a handshake this build cannot read says nothing about the token
+            print(f"note: the saved login could not be checked ({error}); using its token")
+        else:
+            if login.status is not LoginStatus.CONNECTED:
+                print(f"note: the login handshake reads {login.status.value} ({login.message}); using its token")
+        # The lock is taken only once the things that can still refuse this run have been checked: a process that
+        # takes the lock and then exits is a start the reader was told had worked.
+        lock = SingletonLock(Worker(state_dir).lock)
+        if not lock.acquire(wait=0.2):  # a probe takes the lock for an instant; a short wait tells the two apart
+            print("another bridge is running; `zettcode-weixin status` says which, `stop` ends it")
+            return 3
+        guard = DaemonGuard(
+            workspace=Path(state.workspace or Path.cwd()),
+            state=state,
+            model=state.model or None,
+            effort=state.effort or None,
+            permission=state.permission or "safe",
+            name="weixin bridge",
+        )
+        await link.start()
+        if not await link.connected():
+            print("warning: the session broker is not reachable; the first message will say so")
+        bridge = Bridge(
+            im=client,
+            guard=guard,
+            link=link,
+            state=state,
+            path=state_dir / "state.json",
+            settings=BridgeSettings(
+                allow=frozenset(state.allow),
+                allow_all=state.allow_all,
+            ),
+            error=_log,
+        )
+        _on_signals(bridge.stop)
+        print(f"weixin bridge running for {state.workspace or Path.cwd()}; ctrl-c stops it")
+        if state.allow_all:
+            print("allows anyone who can message the bot")
+        elif state.allow:
+            print(f"allows: {', '.join(state.allow)}")
+        else:
+            print("allows nobody yet: each message is refused and names the id to allow")
+        print(f"daemon session: {state.session_id or '(starts on the first message)'}")
+        await bridge.run()
+        return 0
+    finally:
+        await link.close()
+        await client.aclose()
+        if lock is not None:
+            lock.release()
+
+
+def _bridge_id(state_dir: Path) -> str:
+    """Return the broker id of the bridge in one directory: stable per bridge, different between two of them.
+
+    Two bridges — two WeChat accounts, or a stale worker on another ``--state-dir`` — would otherwise claim the
+    same session on the broker, and the second would see every send refused as if it were the agent's fault.
+    """
+    import hashlib
+
+    return "im-weixin-" + hashlib.sha1(str(state_dir.resolve()).encode("utf-8")).hexdigest()[:8]
+
+
+def _on_signals(stop: object) -> None:
+    """Stop the bridge on ctrl-c and on the signal a stop sends, whatever this platform offers."""
+    loop = asyncio.get_running_loop()
+    for number in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(number, stop)  # type: ignore[arg-type]
+        except (NotImplementedError, RuntimeError, ValueError):  # pragma: no cover - Windows, and not the main thread
+            with contextlib.suppress(ValueError, OSError):
+                signal.signal(number, lambda *_: stop())  # type: ignore[operator]
+
+
+def _log(said: str) -> None:
+    """Say one thing where a background process's reader can find it."""
+    print(said, flush=True)
+
+
+# -- status, stop, logs --------------------------------------------------------------------------------
+def _status(state_dir: Path) -> int:
+    """Say whether a bridge is running and what it knows."""
+    from ..state import BridgeState
+
+    worker = Worker(state_dir)
+    state = BridgeState.load(state_dir / "state.json")
+    print(f"bridge:    running (pid {worker.pid()})" if worker.running() else "bridge:    not running")
+    print(f"wechat:    {'logged in' if state.logged_in else 'not logged in'}")
+    print(f"workspace: {state.workspace or '(not recorded)'}")
+    print(f"session:   {state.session_id or '(the daemon starts on the first message)'}")
+    short = state.cursor[:12] + ("\u2026" if len(state.cursor) > 12 else "") if state.cursor else "(none)"
+    print(f"cursor:    {short}")
+    if state.allow_all:
+        print("allows:    everyone who can message the bot")
+    elif state.allow:
+        print(f"allows:    {', '.join(state.allow)}")
+    else:
+        print("allows:    nobody yet")
+    print(f"state:     {state_dir / 'state.json'}")
+    print(f"log:       {worker.log}")
+    return 0
+
+
+__all__ = ["DEFAULT_DIR", "LOGIN_TIMEOUT", "POLL", "build_parser", "main"]
+
+
+if __name__ == "__main__":  # the background process runs this module, not the console script
+    sys.exit(main())

zettcode/im/weixin/qr.py

@@ -0,0 +1,45 @@
+"""A QR code in the terminal, from the payload the login handshake carries.
+
+Two modules of the code share one character: the top half and the bottom half are drawn as ``▀`` and ``▄``, so
+a code of 33 modules is 17 lines and fits above the fold of a normal window. A terminal that cannot show those
+characters still shows the link the handshake also carries, which the caller prints beside it.
+"""
+
+from __future__ import annotations
+
+#: Columns of white around the code. Below the four a spec asks for, and above the zero that makes a scanner
+#: fight the text next to it.
+BORDER = 2
+
+#: The character for each pair of modules: (top, bottom) drawn into one cell.
+_CELLS = {(True, True): "\u2588", (True, False): "\u2580", (False, True): "\u2584", (False, False): " "}
+
+
+def render(payload: str, *, border: int = BORDER) -> str:
+    """Return ``payload`` as a QR code drawn with half-block characters, one line per two rows of modules."""
+    if not payload.strip():
+        raise ValueError("a QR code needs something to encode")
+    import qrcode  # type: ignore[import-untyped]
+
+    code = qrcode.QRCode(border=border, error_correction=qrcode.constants.ERROR_CORRECT_M)
+    code.add_data(payload)
+    code.make(fit=True)
+    matrix = code.get_matrix()
+    rows = len(matrix)
+    lines: list[str] = []
+    for top in range(0, rows, 2):
+        bottom = top + 1
+        line = "".join(
+            _CELLS[(bool(matrix[top][column]), bool(matrix[bottom][column]) if bottom < rows else False)]
+            for column in range(len(matrix[top]))
+        )
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def show(payload: str, *, border: int = BORDER) -> str:
+    """Return the code with the blank line a terminal needs above and below it."""
+    return "\n" + render(payload, border=border) + "\n"
+
+
+__all__ = ["BORDER", "render", "show"]

zettcode/im/weixin/worker.py

@@ -0,0 +1,160 @@
+"""The background process, and the files that say whether it is there.
+
+Three files live in the bridge's directory:
+
+- ``worker.lock`` — held by the running process for as long as it runs. The operating system drops it when the
+  process dies, so this is what "is a bridge running" means; a pid in a file cannot answer that, because a pid
+  outlives its process while the system hands it to somebody else.
+- ``worker.pid`` — the number to signal. Read only while the lock says somebody is there.
+- ``worker.log`` — everything the process printed, appended across restarts so a reason is still there after
+  the restart that hid it.
+
+Starting is a handover: the new process takes the lock, and the parent waits for that before it says the bridge
+is up, so a process that dies on its first line is reported instead of announced.
+"""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+#: How long a starting process has to take the lock, and how long it has to let go of it when told to stop.
+READY_TIMEOUT = 40.0
+STOP_TIMEOUT = 15.0
+
+#: Seconds between looks at the lock while waiting for a start or a stop.
+POLL = 0.1
+
+
+@dataclass
+class Worker:
+    """The background process of one bridge, in one directory."""
+
+    directory: Path
+
+    @property
+    def lock(self) -> Path:
+        """The file the running process holds."""
+        return self.directory / "worker.lock"
+
+    @property
+    def pid_file(self) -> Path:
+        """The file naming the process to signal."""
+        return self.directory / "worker.pid"
+
+    @property
+    def log(self) -> Path:
+        """Where the process writes what it prints."""
+        return self.directory / "worker.log"
+
+    # -- what a reader asks ---------------------------------------------------------------------------
+    def running(self) -> bool:
+        """Return whether a bridge process is alive now."""
+        from zettcode.filelock import is_held
+
+        return is_held(self.lock)
+
+    def pid(self) -> int | None:
+        """Return the pid of the running bridge, or ``None`` when there is none."""
+        if not self.running():
+            return None
+        try:
+            return int(self.pid_file.read_text(encoding="utf-8").strip())
+        except (OSError, ValueError):
+            return None
+
+    def tail(self, lines: int = 40) -> str:
+        """Return the end of the log, for a reader who asks why nothing happened."""
+        try:
+            text = self.log.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ""
+        return "\n".join(text.splitlines()[-lines:])
+
+    # -- what a reader does ---------------------------------------------------------------------------
+    def start(self, argv: list[str], *, timeout: float = READY_TIMEOUT) -> int:
+        """Start the process and return its pid once it has taken the lock.
+
+        Raises:
+            RuntimeError: A bridge is already running, or the new process exited before it was ready; the
+                message carries the end of its log, which is where the reason is.
+        """
+        if self.running():
+            raise RuntimeError(f"a bridge is already running (pid {self.pid()}); stop it first")
+        self.directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+        with open(self.log, "a", encoding="utf-8") as log:
+            log.write(f"\n--- {time.strftime('%Y-%m-%d %H:%M:%S')} starting\n")
+            log.flush()
+            # Unbuffered, so what the process says before it is killed is in the log: a file is block-buffered,
+            # and a start that fails early is exactly the case this log exists for.
+            environment = {**os.environ, "PYTHONUNBUFFERED": "1"}
+            if os.name == "nt":  # pragma: no cover - the platform's own way of saying "not in this console's group"
+                process = subprocess.Popen(  # noqa: S603 - the arguments are this program's own module and flags
+                    argv,
+                    stdin=subprocess.DEVNULL,
+                    stdout=log,
+                    stderr=subprocess.STDOUT,
+                    close_fds=True,
+                    env=environment,
+                    creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
+                )
+            else:
+                process = subprocess.Popen(  # noqa: S603 - as above
+                    argv,
+                    stdin=subprocess.DEVNULL,
+                    stdout=log,
+                    stderr=subprocess.STDOUT,
+                    close_fds=True,
+                    env=environment,
+                    start_new_session=True,
+                )
+        self.pid_file.write_text(str(process.pid), encoding="utf-8")
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if self.running():
+                return process.pid
+            code = process.poll()
+            if code is not None:
+                reason = self.tail(20) or f"it exited with status {code} and said nothing"
+                raise RuntimeError(f"the bridge exited before it was ready:\n{reason}")
+            time.sleep(POLL)
+        raise RuntimeError(f"the bridge did not start within {int(timeout)} seconds; see {self.log}")
+
+    def stop(self, *, timeout: float = STOP_TIMEOUT) -> str:
+        """Stop the process and return a sentence saying what happened."""
+        if not self.running():
+            return "no bridge is running"
+        pid = self.pid()
+        if pid is None:
+            return f"a bridge holds {self.lock} but left no pid to signal"
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except OSError as error:
+            return f"could not signal the bridge (pid {pid}): {error}"
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if not self.running():
+                return f"stopped the bridge (pid {pid})"
+            time.sleep(POLL)
+        try:
+            os.kill(pid, getattr(signal, "SIGKILL", signal.SIGTERM))
+        except OSError:
+            return f"the bridge (pid {pid}) did not stop and could not be killed"
+        for _ in range(int(5 / POLL)):
+            if not self.running():
+                break
+            time.sleep(POLL)
+        return f"the bridge (pid {pid}) did not stop in {int(timeout)} seconds; it was killed"
+
+
+def command(*flags: str) -> list[str]:
+    """Return the command line that runs the worker: this interpreter, this program, ``run`` and ``flags``."""
+    return [sys.executable, "-m", "zettcode.im.weixin.cli", "run", *flags]
+
+
+__all__ = ["READY_TIMEOUT", "STOP_TIMEOUT", "Worker", "command"]

zettcode_im-0.4.2.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.5
+Name: zettcode-im
+Version: 0.4.2
+Summary: Chat bridges: a WeChat conversation that drives one ZettCode daemon, and a place for the next chat app
+Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
+Author: Chang-LeHung
+License-Expression: MIT
+Keywords: bridge,daemon,im,wechat,zettcode
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: agim<0.1,>=0.0.3
+Requires-Dist: qrcode<9,>=8
+Requires-Dist: zettcode-broker
+Requires-Dist: zettcode-engine
+Requires-Dist: zettcode-sdk

zettcode_im-0.4.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+zettcode/im/__init__.py,sha256=GMN__-jXMyEqjGhqPKeyLJIvGfRgDnFY6CBTQlWcxtw,1002
+zettcode/im/bridge.py,sha256=HgE1uN2aL1QWRvMdx22frsGbv7L-7yT53P5kpd26knE,17999
+zettcode/im/guard.py,sha256=AlHiuQKM9S_SEsB4EjgHTHgXnNJ_EebO9rISfn51yMY,6405
+zettcode/im/link.py,sha256=RC_b8qJz9tqCBwlxu0F0_8qoRSdiG2RXZ8wMyH_zx7c,10905
+zettcode/im/state.py,sha256=dexA2U5xsBU8iOFBRYKj4IMwkquQu-dOkrnCiRMDMBQ,9224
+zettcode/im/weixin/__init__.py,sha256=mmClFFsf0cXeRZLCWa48K25fW_q4YR6-FW7N7FDp0-8,168
+zettcode/im/weixin/cli.py,sha256=-pBBa42hotwdb33ezFg7_1SVJYzw8U5zStw0HvgWX48,17383
+zettcode/im/weixin/qr.py,sha256=z00AIENqdU6iWaf3bM2im-3fv0NlPbuM0C889vJZuxc,1850
+zettcode/im/weixin/worker.py,sha256=AbD2EDVSvSjTunfvysJtVBL-b8mwIOp0ZbJbO0Y7qv0,6721
+zettcode_im-0.4.2.dist-info/METADATA,sha256=y_wKPECYeoZJ82LwpRqjNHyKWHWmp1y2i1QCc4JHb60,872
+zettcode_im-0.4.2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+zettcode_im-0.4.2.dist-info/entry_points.txt,sha256=uGNXx1PUYjrqqiqNivK7v6wRSS5GAPuL0Fd-dGt6bK8,64
+zettcode_im-0.4.2.dist-info/RECORD,,

zettcode_im-0.4.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

zettcode_im-0.4.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zettcode-weixin = zettcode.im.weixin.cli:main