zettcode-im 0.4.2__tar.gz → 0.4.4__tar.gz

{zettcode_im-0.4.2 → zettcode_im-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode-im
-Version: 0.4.2
+Version: 0.4.4
 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

{zettcode_im-0.4.2 → zettcode_im-0.4.4}/src/zettcode/im/guard.py

@@ -47,8 +47,10 @@ class DaemonGuard:
         workspace: The directory the daemon works in.
         state: Where the session id lives between runs; the guard writes it when it learns one.
         model: The model by name, or ``None`` for the first configured.
-        effort: The reasoning level, or ``None`` for the model's own.
-        permission: The shell level the daemon gets: ``deny``, ``safe`` or ``full``.
+        effort: The reasoning level, or ``None`` for the middle of the ones the model takes — providers do not all
+            accept every level, and a daemon nobody is watching should reason as much as its model will by default.
+        permission: The shell level the daemon gets: ``deny``, ``safe`` or ``full``. ``full`` by default, the same
+            one ``zettcode daemon spawn`` starts with: there is nobody to answer a sandbox's questions from a chat.
         name: The label recorded beside the daemon, so a reader finds it in ``zettcode daemon list``.
         waits: The waits between failed starts, in order; the last one repeats.
     """
@@ -57,7 +59,7 @@ class DaemonGuard:
     state: BridgeState
     model: str | None = None
     effort: str | None = None
-    permission: str = "safe"
+    permission: str = "full"
     name: str = "chat bridge"
     waits: tuple[float, ...] = ()
     _lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False, repr=False)
@@ -119,12 +121,12 @@ class DaemonGuard:
 
     async def _start(self, session: str | None) -> str:
         """Start a daemon, resuming ``session`` when there is one, and return its session id."""
-        from zettcode.sdk.daemons import spawn_daemon
+        from zettcode.sdk.daemons import default_effort, spawn_daemon
 
         info = await spawn_daemon(
             Path(self.workspace),
             model=self.model,
-            effort=self.effort,
+            effort=self.effort or default_effort(self.model) or None,
             resume=session,
             name=self.name,
             permission=self.permission,

{zettcode_im-0.4.2 → zettcode_im-0.4.4}/src/zettcode/im/weixin/cli.py

@@ -47,13 +47,21 @@ def build_parser() -> argparse.ArgumentParser:
     commands = parser.add_subparsers(dest="command")
     for name, help_line in (
         ("login", "scan a QR code and start the background process (the default)"),
+        ("start", "start the background process with the stored login, without scanning"),
+        ("set", "change the settings the daemon is started with, and apply them now"),
         ("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")
+        _common(sub, login=name in ("login", "set"), run=name == "run")
+        if name == "set":
+            sub.add_argument(
+                "--keep-daemon",
+                action="store_true",
+                help="leave a running daemon alone; by default it is stopped so the new settings take effect",
+            )
         if name == "login":
             sub.add_argument(
                 "--login-timeout",
@@ -85,7 +93,7 @@ def _common(sub: argparse.ArgumentParser, *, login: bool, run: bool) -> None:
             "--permission",
             choices=("deny", "safe", "full"),
             default=None,
-            help="the daemon's shell level (default: the one already stored, or safe)",
+            help="the daemon's shell level (default: the one already stored, or full)",
         )
         sub.add_argument(
             "--allow",
@@ -114,6 +122,10 @@ def main(argv: list[str] | None = None) -> int:
     state_dir: Path = arguments.state_dir.expanduser()
     if arguments.command == "login":
         return asyncio.run(_login(arguments, state_dir))
+    if arguments.command == "start":
+        return _start(state_dir)
+    if arguments.command == "set":
+        return _set(arguments, state_dir)
     if arguments.command == "run":
         return asyncio.run(_run(arguments, state_dir))
     if arguments.command == "status":
@@ -186,22 +198,12 @@ async def _login(arguments: argparse.Namespace, state_dir: Path) -> int:
     # 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)
+    previous_workspace = state.workspace
+    previous_session = state.session_id
+    _apply_settings(state, arguments)
+    if state.workspace != previous_workspace:
+        # A session lives in one workspace: its id in another would resume a conversation that is not there.
+        state.session_id = ""
     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.
@@ -216,6 +218,24 @@ async def _login(arguments: argparse.Namespace, state_dir: Path) -> int:
             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()
+    if previous_session and state.workspace != previous_workspace:
+        # The daemon of the old workspace is nobody's now: the bridge will start a new one here, and leaving the old
+        # one running is a session a reader never asked to keep. Best effort: a busy one is reported, not waited on.
+        from zettcode.sdk.daemons import stop_daemon
+        from zettcode.sdk.errors import SessionNotFoundError
+
+        try:
+            said = await stop_daemon(previous_session, keep=True)
+        except SessionNotFoundError:
+            said = "no daemon was running for the old workspace"
+        except Exception as error:  # noqa: BLE001 - the login is finished either way
+            said = f"the daemon of the old workspace was left running ({error})"
+        print(f"daemon     {said}")
+    elif previous_session and (arguments.model or arguments.effort or arguments.permission):
+        print(
+            "note       a daemon that is already running keeps the settings it was started with; "
+            "`zettcode-weixin set` applies new ones now"
+        )
     try:
         pid = worker.start(command("--state-dir", str(state_dir)))
     except RuntimeError as error:
@@ -280,7 +300,7 @@ async def _run(arguments: argparse.Namespace, state_dir: Path) -> int:
             state=state,
             model=state.model or None,
             effort=state.effort or None,
-            permission=state.permission or "safe",
+            permission=state.permission or "full",
             name="weixin bridge",
         )
         await link.start()
@@ -327,6 +347,206 @@ def _bridge_id(state_dir: Path) -> str:
     return "im-weixin-" + hashlib.sha1(str(state_dir.resolve()).encode("utf-8")).hexdigest()[:8]
 
 
+# -- settings ------------------------------------------------------------------------------------------
+def _apply_settings(state: object, arguments: argparse.Namespace) -> None:
+    """Take the flags that were given and leave the ones that were not: a re-scan renews the connection, not the
+    decisions.
+
+    ``None`` is how the parser says "not given" for every one of these, which is why ``--allow`` defaults to
+    ``None`` rather than to an empty list: an empty list means "nobody is allowed", and forgetting a flag must not
+    mean that.
+    """
+    if arguments.workspace is not None:
+        state.workspace = str(Path(arguments.workspace).expanduser().resolve())  # type: ignore[attr-defined]
+    elif not state.workspace:  # type: ignore[attr-defined]
+        state.workspace = str(Path.cwd())  # type: ignore[attr-defined]
+    if arguments.model is not None:
+        state.model = arguments.model  # type: ignore[attr-defined]
+    if arguments.effort is not None:
+        state.effort = arguments.effort  # type: ignore[attr-defined]
+    if arguments.permission is not None:
+        state.permission = arguments.permission  # type: ignore[attr-defined]
+    elif not state.permission:  # type: ignore[attr-defined]
+        state.permission = "full"  # type: ignore[attr-defined]
+    if arguments.allow is not None:
+        state.allow = list(arguments.allow)  # type: ignore[attr-defined]
+    if arguments.allow_all is not None:
+        state.allow_all = bool(arguments.allow_all)  # type: ignore[attr-defined]
+
+
+def _start(state_dir: Path) -> int:
+    """Start the background process with the login that is already stored: what a scan ends with, without the scan."""
+    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` to scan one")
+        return 2
+    worker = Worker(state_dir)
+    if worker.running():
+        print(f"the bridge is already running (pid {worker.pid()})")
+        return 0
+    try:
+        pid = worker.start(command("--state-dir", str(state_dir)))
+    except RuntimeError as error:
+        print(f"the bridge did not start: {error}")
+        return 3
+    print(
+        f"bridge running (pid {pid}); allows: {', '.join(state.allow) or ('anyone' if state.allow_all else 'nobody')}"
+    )
+    return 0
+
+
+def _setting_problem(arguments: argparse.Namespace, state: object) -> str:
+    """Return what is wrong with the settings asked for, or an empty string.
+
+    Checked before anything is stopped or written: a level or a model the machine does not have would otherwise be
+    saved and fail on the next message, with the old daemon already gone and a chat waiting for an answer.
+    """
+    from zettcode.sdk.models import list_models
+
+    if arguments.workspace is not None and not Path(arguments.workspace).expanduser().is_dir():
+        return f"no such directory: {arguments.workspace}"
+    try:
+        models = list(list_models())
+    except (OSError, ValueError) as error:
+        return f"the model configuration cannot be read: {error}"
+    wanted = arguments.model if arguments.model is not None else getattr(state, "model", "")
+    chosen = None
+    if wanted:
+        matched = [info for info in models if info.name == wanted or info.model == wanted]
+        if len(matched) != 1:
+            return f"no model named {wanted!r}; `zettcode daemon model` lists the ones there are"
+        chosen = matched[0]
+    elif models:
+        chosen = models[0]
+    if arguments.effort is not None and chosen is not None:
+        levels = [str(level) for level in chosen.efforts]
+        if arguments.effort not in levels:
+            return f"{chosen.name} takes {', '.join(levels) or 'no level'}, not {arguments.effort!r}"
+    return ""
+
+
+def _set(arguments: argparse.Namespace, state_dir: Path) -> int:
+    """Write the settings a daemon is started with, and put them in force now.
+
+    Two things keep the old values alive if this only wrote the file: a running daemon was started with the old
+    level, and the background process read the file once at its own start. So the daemon is stopped (the bridge
+    starts it again with the stored settings on the next message) and the process is restarted.
+
+    The daemon is stopped *before* the file is written, and a daemon that is busy stops the whole command: it would
+    otherwise keep running with the old settings while the file describes new ones, and the bridge would find it
+    alive and never start the one the reader asked for.
+    """
+    import asyncio
+
+    from zettcode.sdk.daemons import stop_daemon
+    from zettcode.sdk.errors import ConfigurationError, SessionNotFoundError
+
+    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` to scan one")
+        return 2
+    problem = _setting_problem(arguments, state)
+    if problem:
+        print(f"not changed: {problem}")
+        return 2
+
+    worker = Worker(state_dir)
+    was_running = worker.running()
+    if was_running:
+        print(worker.stop())
+        if worker.running():
+            # It would read the old file and write its own copy back over the new one.
+            print("not changed: the bridge did not stop; stop it by hand and run the command again")
+            return 3
+    if state.session_id and not arguments.keep_daemon:
+        try:
+            said = asyncio.run(stop_daemon(state.session_id, keep=True))
+        except SessionNotFoundError:
+            said = "no daemon was running for it"
+        except ConfigurationError as error:
+            print(f"not changed: the daemon is still doing what it was: {error}")
+            if was_running:
+                _restart_worker(worker, state_dir)
+            return 3
+        except Exception as error:  # noqa: BLE001 - any other failure is still a stop that did not happen
+            print(f"not changed: the daemon could not be stopped: {error}")
+            if was_running:
+                _restart_worker(worker, state_dir)
+            return 3
+        print(f"daemon     {said}")
+
+    previous_workspace = state.workspace
+    _apply_settings(state, arguments)
+    if state.workspace != previous_workspace:
+        # A session lives in one workspace; carrying its id over would resume a conversation that is not there.
+        state.session_id = ""
+        state.chats.clear()
+    dropped = _drop_incompatible_effort(state)
+    state.save()
+    print(f"workspace  {state.workspace or Path.cwd()}")
+    print(f"model      {state.model or '(the first configured)'}")
+    print(f"effort     {state.effort or '(the middle of what the model takes)'}")
+    print(f"shell      {state.permission}")
+    if dropped:
+        print(f"note       {dropped}")
+    if state.allow_all:
+        print("allows     anyone who can message the bot")
+    else:
+        print(f"allows     {', '.join(state.allow) or 'nobody'}")
+
+    if was_running:
+        pid = _restart_worker(worker, state_dir)
+        if pid is None:
+            return 3
+        print(f"bridge     running (pid {pid})")
+    else:
+        print("bridge     not running; `zettcode-weixin start` reads the new settings")
+    return 0
+
+
+def _drop_incompatible_effort(state: object) -> str:
+    """Clear a stored level the model it now runs on does not take, and say so; return an empty string otherwise.
+
+    A level belongs to a model. Keeping ``high`` after moving to a model that stops at ``low`` would fail at the
+    next start, with the old daemon already gone — so the level goes, and the middle of the new model's list
+    applies instead.
+    """
+    from zettcode.sdk.models import list_models
+
+    effort = getattr(state, "effort", "")
+    if not effort:
+        return ""
+    try:
+        models = list(list_models())
+    except (OSError, ValueError):
+        return ""
+    wanted = getattr(state, "model", "")
+    chosen = next((info for info in models if wanted and (info.name == wanted or info.model == wanted)), None)
+    if chosen is None:
+        chosen = models[0] if models else None
+    if chosen is None:
+        return ""
+    levels = [str(level) for level in chosen.efforts]
+    if effort in levels:
+        return ""
+    state.effort = ""  # type: ignore[attr-defined]
+    return f"the level {effort!r} is not one {chosen.name} takes ({', '.join(levels) or 'none'}), so it is unset"
+
+
+def _restart_worker(worker: Worker, state_dir: Path) -> int | None:
+    """Start the background process again and return its pid, or say why it did not start."""
+    try:
+        pid = worker.start(command("--state-dir", str(state_dir)))
+    except RuntimeError as error:
+        print(f"the bridge did not start again: {error}")
+        return None
+    return pid
+
+
 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()