monash-study-kit 1.2.0__py3-none-any.whl

monash_study_kit/__init__.py

@@ -0,0 +1,4 @@
+"""Monash 学习助手：把 Moodle 和 Ed 接进 Claude。"""
+# 发新版就改这里（pyproject 从这里读）：朋友那边的更新提示比的就是 main 上的这个号。
+# 修 bug 加最后一位，加功能加中间一位。CI 会检查改了 src/ 的 PR 有没有改它。
+__version__ = "1.2.0"

monash_study_kit/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

monash_study_kit/browser_login.py

@@ -0,0 +1,213 @@
+"""专用登录窗口：用单独的浏览器配置目录打开 Moodle，登录完只从这个窗口里取 Moodle 的 cookie。
+
+为什么这样做：
+  * Monash 走 Okta SAML + MFA，命令行没法自己登录，只能让人在真浏览器里登。
+  * 不去读日常 Chrome 的 cookie：那要钥匙串里的解密密钥，能解开所有网站的登录状态。
+    这里用的是 BROWSER_PROFILE 这个独立目录，里面只有你在这个窗口里登录过的东西。
+  * 独立目录会记住 Okta 的“保持登录”，所以下次过期时可以先在后台（无界面）试着自动登录，
+    Okta 那边还认你的话就不用再弹窗；不认才打开窗口让你登。
+
+浏览器：Chrome、Edge、Brave、Chromium 都行（Windows 自带 Edge）。`monash config browser <路径>` 可以指定。
+Chrome 136 起不许对默认配置目录开远程调试，独立目录不受影响。
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import time
+import urllib.parse
+from pathlib import Path
+
+from .cdp import CDP, PipeCDP, WebSocketClosed
+from .moodlelib import BASE_URL, HOST, MoodleAuthError, MoodleClient, save_cookies
+from .paths import BROWSER, BROWSER_PROFILE, ensure_private_dir
+
+KEEP = ("MoodleSession", "MOODLEID", "AWSALB", "AWSELB")   # 只留 Moodle 自己要的，别存一堆统计 cookie
+
+
+class LoginFailed(RuntimeError):
+    pass
+
+
+def find_browser() -> str | None:
+    if BROWSER:
+        return BROWSER
+    if sys.platform == "darwin":
+        for app, exe in (("Google Chrome", "Google Chrome"), ("Microsoft Edge", "Microsoft Edge"),
+                         ("Brave Browser", "Brave Browser"), ("Chromium", "Chromium")):
+            for root in (Path("/Applications"), Path.home() / "Applications"):
+                p = root / f"{app}.app" / "Contents" / "MacOS" / exe
+                if p.exists():
+                    return str(p)
+        return None
+    if os.name == "nt":
+        roots = [os.environ.get(k) for k in ("PROGRAMFILES", "PROGRAMFILES(X86)", "LOCALAPPDATA")]
+        for rel in (r"Google\Chrome\Application\chrome.exe", r"Microsoft\Edge\Application\msedge.exe",
+                    r"BraveSoftware\Brave-Browser\Application\brave.exe"):
+            for root in filter(None, roots):
+                p = Path(root) / rel
+                if p.exists():
+                    return str(p)
+        return None
+    for name in ("google-chrome", "google-chrome-stable", "chromium", "chromium-browser",
+                 "microsoft-edge", "brave-browser"):
+        if shutil.which(name):
+            return shutil.which(name)
+    return None
+
+
+class Browser:
+    """一个用 BROWSER_PROFILE 启动、能用 CDP 控制的浏览器（POSIX 走管道，Windows 走本机端口）。"""
+
+    def __init__(self, url: str, headless: bool = False):
+        exe = find_browser()
+        if not exe:
+            raise LoginFailed("没找到 Chrome / Edge / Brave。装一个 Chrome，或者用 monash config browser <路径> 指定浏览器程序")
+        ensure_private_dir(BROWSER_PROFILE)
+        flags = ["--no-first-run", "--no-default-browser-check", "--disable-sync",
+                 "--window-size=1100,860", "--new-window", url]
+        if headless:
+            flags.insert(0, "--headless=new")
+        if os.name != "nt":
+            # 不开端口：DevTools 走管道，登录窗口开着的时候本机别的程序也连不上它
+            self.cdp = PipeCDP([exe, f"--user-data-dir={BROWSER_PROFILE}", "--remote-debugging-pipe", *flags])
+            self.proc = self.cdp.proc
+            try:
+                self.cdp.call("Browser.getVersion", timeout=30)
+            except (OSError, RuntimeError, TimeoutError) as e:
+                self.proc.kill()
+                raise LoginFailed("浏览器没能启动（如果这个专用窗口已经开着，先把它关掉再试）") from e
+            return
+        # Windows：随机端口，端口号写在专用配置目录里（只有自己能读）
+        port_file = BROWSER_PROFILE / "DevToolsActivePort"
+        port_file.unlink(missing_ok=True)
+        self.proc = subprocess.Popen([exe, f"--user-data-dir={BROWSER_PROFILE}", "--remote-debugging-port=0", *flags],
+                                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL)
+        deadline = time.monotonic() + 30
+        while time.monotonic() < deadline:
+            if port_file.exists():
+                lines = port_file.read_text(encoding="utf-8").split()
+                if len(lines) >= 2:
+                    self.cdp = CDP(f"ws://127.0.0.1:{lines[0]}{lines[1]}")
+                    return
+            if self.proc.poll() is not None:
+                break
+            time.sleep(0.2)
+        self.proc.kill()
+        raise LoginFailed("浏览器没能启动（如果这个专用窗口已经开着，先把它关掉再试）")
+
+    def cookies(self) -> dict[str, str]:
+        got = self.cdp.call("Storage.getCookies").get("cookies", [])
+        return {c["name"]: c["value"] for c in got
+                if _domain_matches(c.get("domain", "")) and c["name"].startswith(KEEP)}
+
+    def page_urls(self) -> list[str]:
+        infos = self.cdp.call("Target.getTargets").get("targetInfos", [])
+        return [t.get("url", "") for t in infos if t.get("type") == "page"]
+
+    def close(self) -> None:
+        try:
+            self.cdp.call("Browser.close", timeout=5)
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            self.cdp.close()
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            self.proc.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            self.proc.kill()
+
+
+def _domain_matches(domain: str) -> bool:
+    """cookie 的 domain 是 Moodle 本站或它的上级域名。按点分段比，免得 "ash.edu" 也算进 monash.edu。"""
+    d = domain.lstrip(".").lower()
+    return bool(d) and (HOST == d or HOST.endswith("." + d))
+
+
+def _on_moodle(urls: list[str]) -> bool:
+    """有页面停在 Moodle 本站、而且不是登录页，大概登录完了，值得验证一下。"""
+    for u in urls:
+        p = urllib.parse.urlsplit(u)
+        if p.hostname == HOST and not p.path.startswith(("/login", "/auth")):
+            return True
+    return False
+
+
+def _on_okta(urls: list[str]) -> bool:
+    return any((urllib.parse.urlsplit(u).hostname or "").endswith("okta.com") for u in urls)
+
+
+def login_moodle(interactive: bool = True, timeout: float = 300, log=print) -> dict:
+    """登录 Moodle 并保存 cookie。返回 {"userid", "time_remaining"}。
+
+    interactive=False：无界面试一次，靠专用目录里记住的 Okta 登录状态自动登进去；停在 Okta
+    登录页超过 20 秒就算失败（调用方再决定要不要弹窗）。
+    """
+    browser = Browser(f"{BASE_URL}/my/", headless=not interactive)
+    if interactive:
+        log("已打开登录窗口：在里面登录 Monash（Okta + MFA），登录成功后窗口会自动关闭。")
+    started = time.monotonic()
+    tried: dict[str, float] = {}     # 会话值 → 上次验证的时间；登录前的匿名会话也叫 MoodleSession
+    try:
+        while time.monotonic() - started < timeout:
+            time.sleep(1.5)
+            try:
+                urls = browser.page_urls()
+                jar = browser.cookies()
+            except (WebSocketClosed, OSError):
+                raise LoginFailed("登录窗口被关掉了，没有完成登录") from None
+            if not interactive and _on_okta(urls) and time.monotonic() - started > 20:
+                raise LoginFailed("自动登录不行（Okta 要重新输入密码或 MFA）")
+            session = jar.get("MoodleSession")
+            if not session or not _on_moodle(urls) or time.monotonic() - tried.get(session, -99) < 6:
+                continue
+            tried[session] = time.monotonic()
+            client = MoodleClient(dict(jar), persist=False)
+            try:
+                left = client.time_remaining()
+            except MoodleAuthError:
+                continue
+            save_cookies(client.jar)
+            _save_calendar_url(client, log)
+            return {"userid": client.userid, "time_remaining": left}
+        raise LoginFailed("等了太久还没登录成功" if interactive else "自动登录超时")
+    finally:
+        browser.close()
+
+
+def _save_calendar_url(client: MoodleClient, log) -> None:
+    """顺手存下 iCal 订阅链接：以后会话过期了，截止日期还能靠它拿到。"""
+    from . import features as F
+    if F.load_calendar_url():
+        return
+    try:
+        F.calendar_url(client)
+    except Exception as e:  # noqa: BLE001
+        log(f"（日历订阅链接没拿到：{e}）")
+
+
+def ensure_login(log=print, allow_window: bool = True) -> dict:
+    """先无界面试自动登录（专用窗口以前登录过才试），不行再开窗口。"""
+    if (BROWSER_PROFILE / "Default").exists():
+        try:
+            return login_moodle(interactive=False, timeout=45, log=log)
+        except LoginFailed as e:
+            if not allow_window:
+                raise
+            log(f"{e}，打开登录窗口…")
+    elif not allow_window:
+        raise LoginFailed("还没在登录窗口里登录过，没法自动登录")
+    return login_moodle(interactive=True, log=log)
+
+
+def session_ok() -> bool:
+    try:
+        MoodleClient().time_remaining()
+        return True
+    except (MoodleAuthError, OSError):
+        return False
+

monash_study_kit/cdp.py

@@ -0,0 +1,188 @@
+"""和 Chrome DevTools 协议（CDP）说话用的最小 WebSocket 客户端。
+
+标准库没有 WebSocket，这里只实现 CDP 用得到的部分：握手、发文本帧（客户端必须加掩码）、
+收文本帧（含分片）、回 ping。不发 Origin 头，因为 Chrome 只对带 Origin 的连接要求
+--remote-allow-origins，不带就放行。只连 127.0.0.1。
+
+macOS 和 Linux 上不开端口，用 PipeCDP：DevTools 走 fd 3/4 两根管道（--remote-debugging-pipe），
+本机别的程序和别的用户都连不上。Windows 没有 fork/exec 时挪 fd 的办法，只能用端口。
+"""
+from __future__ import annotations
+
+import base64
+import json
+import os
+import socket
+import struct
+import subprocess
+import time
+import urllib.parse
+
+
+class WebSocketClosed(ConnectionError):
+    """浏览器关了（或者用户把登录窗口关了）。"""
+
+
+class WebSocket:
+    def __init__(self, url: str, timeout: float = 10):
+        u = urllib.parse.urlsplit(url)
+        if u.scheme != "ws" or u.hostname not in ("127.0.0.1", "localhost"):
+            raise ValueError("只连本机的 DevTools")
+        self.sock = socket.create_connection((u.hostname, u.port or 80), timeout=timeout)
+        key = base64.b64encode(os.urandom(16)).decode()
+        path = u.path + (f"?{u.query}" if u.query else "")
+        self.sock.sendall((f"GET {path} HTTP/1.1\r\nHost: {u.hostname}:{u.port}\r\n"
+                           "Upgrade: websocket\r\nConnection: Upgrade\r\n"
+                           f"Sec-WebSocket-Key: {key}\r\nSec-WebSocket-Version: 13\r\n\r\n").encode())
+        head = b""
+        while b"\r\n\r\n" not in head:
+            chunk = self.sock.recv(4096)
+            if not chunk:
+                raise WebSocketClosed("握手时连接断了")
+            head += chunk
+        head, self._buf = head.split(b"\r\n\r\n", 1)
+        if b" 101 " not in head.split(b"\r\n", 1)[0]:
+            raise ConnectionError(f"DevTools 拒绝了 WebSocket：{head[:200]!r}")
+
+    def _read(self, n: int) -> bytes:
+        while len(self._buf) < n:
+            chunk = self.sock.recv(65536)
+            if not chunk:
+                raise WebSocketClosed("浏览器已关闭")
+            self._buf += chunk
+        out, self._buf = self._buf[:n], self._buf[n:]
+        return out
+
+    def _send_frame(self, opcode: int, payload: bytes) -> None:
+        head = bytes([0x80 | opcode])
+        n = len(payload)
+        if n < 126:
+            head += bytes([0x80 | n])
+        elif n < 1 << 16:
+            head += bytes([0x80 | 126]) + struct.pack(">H", n)
+        else:
+            head += bytes([0x80 | 127]) + struct.pack(">Q", n)
+        mask = os.urandom(4)
+        body = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
+        self.sock.sendall(head + mask + body)
+
+    def send(self, text: str) -> None:
+        self._send_frame(0x1, text.encode("utf-8"))
+
+    def recv(self) -> str:
+        parts: list[bytes] = []
+        while True:
+            b0, b1 = self._read(2)
+            opcode, n = b0 & 0x0F, b1 & 0x7F
+            if n == 126:
+                n = struct.unpack(">H", self._read(2))[0]
+            elif n == 127:
+                n = struct.unpack(">Q", self._read(8))[0]
+            mask = self._read(4) if b1 & 0x80 else None
+            data = self._read(n)
+            if mask:
+                data = bytes(b ^ mask[i % 4] for i, b in enumerate(data))
+            if opcode == 0x8:
+                raise WebSocketClosed("浏览器关闭了连接")
+            if opcode == 0x9:
+                self._send_frame(0xA, data)
+                continue
+            if opcode in (0x1, 0x0):
+                parts.append(data)
+                if b0 & 0x80:
+                    return b"".join(parts).decode("utf-8", "replace")
+
+    def close(self) -> None:
+        try:
+            self._send_frame(0x8, b"")
+        except OSError:
+            pass
+        self.sock.close()
+
+
+class CDP:
+    """浏览器级的 CDP 会话：call() 发命令等结果，中间收到的事件丢掉。"""
+
+    def __init__(self, ws_url: str):
+        self.ws = WebSocket(ws_url)
+        self._id = 0
+
+    def call(self, method: str, params: dict | None = None, timeout: float = 15) -> dict:
+        self._id += 1
+        mid = self._id
+        self.ws.send(json.dumps({"id": mid, "method": method, "params": params or {}}))
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            msg = json.loads(self.ws.recv())
+            if msg.get("id") == mid:
+                if "error" in msg:
+                    raise RuntimeError(f"{method}: {msg['error'].get('message')}")
+                return msg.get("result") or {}
+        raise TimeoutError(f"{method} 没有回应")
+
+    def close(self) -> None:
+        self.ws.close()
+
+
+class PipeCDP:
+    """--remote-debugging-pipe 上的 CDP：浏览器从 fd 3 读命令、往 fd 4 写回复，消息以 \\0 结尾。只用于 POSIX。"""
+
+    def __init__(self, argv: list[str]):
+        to_child_r, self._to_child = os.pipe()        # 我们写 → 浏览器从 fd 3 读
+        self._from_child, from_child_w = os.pipe()    # 浏览器写 fd 4 → 我们读
+
+        def wire():                                    # 子进程里、exec 之前
+            # 先挪到别的号上再 dup2：管道本身可能就是 fd 3/4，dup2(3, 3) 什么都不做，
+            # close-on-exec 标志还在，exec 时浏览器那头就被关了
+            a, b = os.dup(to_child_r), os.dup(from_child_w)
+            os.dup2(a, 3)
+            os.dup2(b, 4)
+            os.set_inheritable(3, True)
+            os.set_inheritable(4, True)
+
+        self.proc = subprocess.Popen(argv, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+                                     stderr=subprocess.DEVNULL, preexec_fn=wire, close_fds=False)
+        os.close(to_child_r)
+        os.close(from_child_w)
+        os.set_blocking(self._from_child, False)
+        self._buf = b""
+        self._id = 0
+
+    def call(self, method: str, params: dict | None = None, timeout: float = 15) -> dict:
+        self._id += 1
+        mid = self._id
+        try:
+            os.write(self._to_child, json.dumps({"id": mid, "method": method, "params": params or {}}).encode() + b"\0")
+        except OSError as e:
+            raise WebSocketClosed("浏览器已经关掉了") from e
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            while b"\0" in self._buf:
+                raw, self._buf = self._buf.split(b"\0", 1)
+                try:
+                    msg = json.loads(raw)
+                except ValueError:
+                    continue
+                if msg.get("id") == mid:
+                    if "error" in msg:
+                        raise RuntimeError(f"{method}: {msg['error'].get('message')}")
+                    return msg.get("result") or {}
+            try:
+                chunk = os.read(self._from_child, 1 << 16)
+            except BlockingIOError:
+                if self.proc.poll() is not None:
+                    raise WebSocketClosed("浏览器已经关掉了") from None
+                time.sleep(0.05)
+                continue
+            if not chunk:
+                raise WebSocketClosed("浏览器已经关掉了")
+            self._buf += chunk
+        raise TimeoutError(f"{method} 没有回应")
+
+    def close(self) -> None:
+        for fd in (self._to_child, self._from_child):
+            try:
+                os.close(fd)
+            except OSError:
+                pass
+

monash_study_kit/claude_setup.py

@@ -0,0 +1,152 @@
+"""把 monash MCP 加进 Claude Desktop 和 Claude Code。
+
+Claude Desktop 的坑：App 运行时把配置文件攥在内存里，退出时整份写回。开着 App 改
+claude_desktop_config.json，一退出就被覆盖掉。所以必须先完全退出 App（macOS 上我们自动退，
+Windows 上请用户从托盘图标退出），确认进程没了再改。
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+SERVER_NAME = "monash"
+
+
+def server_command() -> list[str]:
+    """启动 MCP 的命令：用装好的 monash 程序的绝对路径，Claude 启动它时不依赖 PATH。"""
+    exe = shutil.which("monash")
+    if exe:
+        return [str(Path(exe).resolve()), "mcp"]
+    return [sys.executable, "-m", "monash_study_kit", "mcp"]
+
+
+# ---------------------------------------------------------------- Claude Desktop
+
+def desktop_config_candidates() -> list[Path]:
+    if sys.platform == "darwin":
+        return [Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"]
+    if os.name == "nt":
+        out = []
+        if os.environ.get("APPDATA"):
+            out.append(Path(os.environ["APPDATA"]) / "Claude" / "claude_desktop_config.json")
+        # 从 Microsoft Store / MSIX 装的版本，配置在包的虚拟化目录里
+        pkgs = Path(os.environ.get("LOCALAPPDATA", "")) / "Packages"
+        if pkgs.exists():
+            for p in pkgs.glob("Claude_*"):
+                out.append(p / "LocalCache" / "Roaming" / "Claude" / "claude_desktop_config.json")
+        return out
+    return [Path.home() / ".config" / "Claude" / "claude_desktop_config.json"]
+
+
+def desktop_config_path() -> Path | None:
+    cands = desktop_config_candidates()
+    for p in cands:
+        if p.exists() or p.parent.exists():
+            return p
+    return None
+
+
+def desktop_running() -> bool:
+    if sys.platform == "darwin":
+        return subprocess.run(["pgrep", "-xq", "Claude"]).returncode == 0
+    if os.name == "nt":
+        r = subprocess.run(["tasklist", "/FI", "IMAGENAME eq Claude.exe", "/NH"], capture_output=True, text=True)
+        return "claude.exe" in r.stdout.lower()
+    return subprocess.run(["pgrep", "-x", "claude-desktop"], capture_output=True).returncode == 0
+
+
+def quit_desktop(wait: int = 60) -> bool:
+    """退出 Claude Desktop 并等进程结束。返回是否已经没在运行。"""
+    if not desktop_running():
+        return True
+    if sys.platform == "darwin":
+        subprocess.run(["osascript", "-e", 'quit app "Claude"'], capture_output=True)
+    else:
+        return False        # Windows 上 Claude 会缩到托盘，让用户自己退出更可靠
+    for _ in range(wait):
+        if not desktop_running():
+            return True
+        time.sleep(1)
+    return False
+
+
+def write_desktop_config(path: Path, command: list[str]) -> Path | None:
+    """加上（或更新）mcpServers.monash，其他内容原样保留。返回备份文件路径。"""
+    cfg, backup = {}, None
+    if path.exists():
+        raw = path.read_text(encoding="utf-8")
+        cfg = json.loads(raw) if raw.strip() else {}
+        backup = path.with_name(path.name + f".bak-{time.strftime('%Y%m%d%H%M%S')}")
+        backup.write_text(raw, encoding="utf-8")
+    cfg.setdefault("mcpServers", {})[SERVER_NAME] = {"command": command[0], "args": command[1:]}
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_text(json.dumps(cfg, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+    return backup
+
+
+def remove_from_desktop_config(path: Path) -> bool:
+    if not path.exists():
+        return False
+    cfg = json.loads(path.read_text(encoding="utf-8") or "{}")
+    if SERVER_NAME not in cfg.get("mcpServers", {}):
+        return False
+    del cfg["mcpServers"][SERVER_NAME]
+    path.write_text(json.dumps(cfg, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return True
+
+
+def open_desktop() -> None:
+    if sys.platform == "darwin":
+        subprocess.run(["open", "-a", "Claude"], capture_output=True)
+
+
+def install_desktop(ask=input, log=print) -> bool:
+    path = desktop_config_path()
+    if path is None:
+        log("没找到 Claude Desktop（没装，或者从没打开过）。装好并打开一次后再运行 monash setup claude")
+        return False
+    if desktop_running():
+        if sys.platform == "darwin":
+            if ask("要先退出 Claude Desktop 才能改它的配置（开着改会被覆盖）。现在退出吗？[Y/n] ").strip().lower() not in ("", "y", "yes"):
+                log("跳过了 Claude Desktop。之后可以运行 monash setup claude")
+                return False
+            if not quit_desktop():
+                log("Claude 60 秒内没退出。手动按 ⌘Q 退出后再运行 monash setup claude")
+                return False
+        else:
+            log("请完全退出 Claude Desktop：右下角托盘里的 Claude 图标 → 右键 → Quit（只关窗口不够）。")
+            for _ in range(3):
+                ask("退出后按回车继续…")
+                if not desktop_running():
+                    break
+            else:
+                log("Claude 还在运行，先跳过。退出后再运行 monash setup claude")
+                return False
+    backup = write_desktop_config(path, server_command())
+    log(f"已把 monash 加进 Claude Desktop（{path}）" + (f"，原配置备份在 {backup.name}" if backup else ""))
+    open_desktop()
+    log("重新打开 Claude Desktop 后，在聊天输入框的“+ → Connectors”里能看到 monash。")
+    return True
+
+
+# ---------------------------------------------------------------- Claude Code
+
+def install_code(log=print) -> bool:
+    claude = shutil.which("claude")
+    if not claude:
+        return False
+    cmd = server_command()
+    subprocess.run([claude, "mcp", "remove", "-s", "user", SERVER_NAME], capture_output=True)
+    r = subprocess.run([claude, "mcp", "add", "-s", "user", SERVER_NAME, "--", *cmd], capture_output=True, text=True)
+    if r.returncode != 0:
+        log(f"加进 Claude Code 失败：{(r.stderr or r.stdout).strip()}")
+        return False
+    log("已把 monash 加进 Claude Code（所有项目都能用）")
+    return True