hipda 0.1.11__py3-none-any.whl

hipda-0.1.11.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: hipda
+Version: 0.1.11
+Summary: CLI reader for 4D4Y/HiPDA Discovery forum posts.
+Requires-Python: >=3.11
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: browser-cookie3>=0.20
+Description-Content-Type: text/markdown
+
+# hipda
+
+CLI reader for the 4D4Y/HiPDA Discovery channel (`fid=2`).
+
+The site uses browser/session checks, so direct unauthenticated requests may return a Cloudflare challenge. Log in once through Chrome:
+
+```bash
+uvx --from . hipda login
+```
+
+From PyPI:
+
+```bash
+uvx hipda login
+```
+
+That opens 4D4Y in Google Chrome. After you finish logging in, return to the terminal and press Enter. Then read Discovery:
+
+```bash
+uvx --from . hipda list --limit 20
+uvx --from . hipda read 3446553
+```
+
+From PyPI:
+
+```bash
+uvx hipda list --limit 20
+uvx hipda read 3446553
+```
+
+`hipda list` also tries to import automatically if Chrome is already logged in, so most of the time you can skip straight to reading. The old `hipda discovery list` and `hipda discovery read` commands still work.
+
+The cookie is stored at `~/.config/hipda/cookie` and the user agent is stored at `~/.config/hipda/user-agent`, both with `0600` permissions. You can override them per command with `HIPDA_COOKIE` / `--cookie` and `HIPDA_USER_AGENT` / `--user-agent`.
+
+You can also pass a browser user agent:
+
+```bash
+HIPDA_USER_AGENT='Mozilla/5.0 ...' uvx --from . hipda list
+```
+
+The CLI disables HTTPS certificate verification by default because 4D4Y often fails from Python environments where Chrome still works. To verify certificates, pass a trusted root certificate and `--verify-tls`:
+
+```bash
+uvx --from . hipda --verify-tls --ca-file /path/to/root-ca.pem list
+```

hipda-0.1.11.dist-info/RECORD

@@ -0,0 +1,10 @@
+hipda_cli/__init__.py,sha256=wOQd_Wj4i4Y_coXW38Gsu3Io76IKVCxgdS5T8ZnJwzg,113
+hipda_cli/auth.py,sha256=yoqnHNc6GccR4aY9q05GfLMPbr-kLhidaDa11BkjsUA,3491
+hipda_cli/cli.py,sha256=Sbo_YN7GtOX1StujM4XrZlp18YQgn_CtngGYirajN2A,9251
+hipda_cli/client.py,sha256=lmeWZgLFq8GDCXtAhEOSHyA2Qk_O5D6juFzNr3rrfio,3286
+hipda_cli/models.py,sha256=jcy9SN3dyTT6lkzlvtZh_67CbpEaPu7dl8c51V2vutE,406
+hipda_cli/parser.py,sha256=wsVn3qFaY42Rg-8DGHUM1SwlvGT4Lgt8FKjR-4hRIFY,4559
+hipda-0.1.11.dist-info/METADATA,sha256=-W0T_mFtLjD_g-eUb5KPzPvvfFFzk_fimESvpoVbINg,1679
+hipda-0.1.11.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+hipda-0.1.11.dist-info/entry_points.txt,sha256=53g4SRiLfISMiXV5kpCDdioyWFh_fuPur-t1v2SIB7g,45
+hipda-0.1.11.dist-info/RECORD,,

hipda-0.1.11.dist-info/WHEEL

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

hipda-0.1.11.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hipda = hipda_cli.cli:main

hipda_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Command-line tools for reading 4D4Y/HiPDA forum content."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.9"

hipda_cli/auth.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import os
+import plistlib
+import subprocess
+from pathlib import Path
+
+import browser_cookie3
+
+
+LOGIN_URL = "https://www.4d4y.com/forum/forumdisplay.php?fid=2"
+
+CHROME_INFO_PLIST_PATHS = (
+    Path("/Applications/Google Chrome.app/Contents/Info.plist"),
+    Path.home() / "Applications/Google Chrome.app/Contents/Info.plist",
+)
+
+
+def default_cookie_path() -> Path:
+    return _config_path("cookie")
+
+
+def default_user_agent_path() -> Path:
+    return _config_path("user-agent")
+
+
+def _config_path(name: str) -> Path:
+    config_home = os.environ.get("XDG_CONFIG_HOME")
+    if config_home:
+        return Path(config_home) / "hipda" / name
+    return Path.home() / ".config" / "hipda" / name
+
+
+def normalize_cookie(cookie: str) -> str:
+    cookie = cookie.strip()
+    if cookie.lower().startswith("cookie:"):
+        cookie = cookie.split(":", 1)[1].strip()
+    return cookie
+
+
+def load_cookie(path: Path | None = None) -> str:
+    cookie_path = path or default_cookie_path()
+    if not cookie_path.exists():
+        return ""
+    return normalize_cookie(cookie_path.read_text(encoding="utf-8"))
+
+
+def save_cookie(cookie: str, path: Path | None = None) -> Path:
+    normalized = normalize_cookie(cookie)
+    if not normalized:
+        raise ValueError("cookie is empty")
+
+    cookie_path = path or default_cookie_path()
+    cookie_path.parent.mkdir(parents=True, exist_ok=True)
+    cookie_path.write_text(normalized + "\n", encoding="utf-8")
+    cookie_path.chmod(0o600)
+    return cookie_path
+
+
+def load_user_agent(path: Path | None = None) -> str:
+    user_agent_path = path or default_user_agent_path()
+    if not user_agent_path.exists():
+        return ""
+    return user_agent_path.read_text(encoding="utf-8").strip()
+
+
+def save_user_agent(user_agent: str, path: Path | None = None) -> Path:
+    normalized = user_agent.strip()
+    if not normalized:
+        raise ValueError("user-agent is empty")
+
+    user_agent_path = path or default_user_agent_path()
+    user_agent_path.parent.mkdir(parents=True, exist_ok=True)
+    user_agent_path.write_text(normalized + "\n", encoding="utf-8")
+    user_agent_path.chmod(0o600)
+    return user_agent_path
+
+
+def cookie_header_from_browser(domain: str = "4d4y.com") -> str:
+    jar = browser_cookie3.chrome(domain_name=domain)
+    cookies = []
+    for cookie in jar:
+        if cookie.domain.lstrip(".") == domain or cookie.domain.endswith("." + domain):
+            cookies.append(f"{cookie.name}={cookie.value}")
+    return "; ".join(cookies)
+
+
+def chrome_user_agent() -> str:
+    major = "147"
+    for plist_path in CHROME_INFO_PLIST_PATHS:
+        if not plist_path.exists():
+            continue
+        with plist_path.open("rb") as file:
+            version = str(plistlib.load(file).get("CFBundleShortVersionString", ""))
+        if version:
+            major = version.split(".", 1)[0]
+            break
+    return (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+        f"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{major}.0.0.0 Safari/537.36"
+    )
+
+
+def import_browser_auth(domain: str = "4d4y.com") -> tuple[str, str]:
+    cookie = cookie_header_from_browser(domain)
+    if not cookie:
+        raise ValueError(f"no {domain} cookies found in Chrome")
+    user_agent = chrome_user_agent()
+    save_cookie(cookie)
+    save_user_agent(user_agent)
+    return cookie, user_agent
+
+
+def open_login_page() -> None:
+    subprocess.run(["open", "-a", "Google Chrome", LOGIN_URL], check=False)

hipda_cli/cli.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .auth import import_browser_auth, open_login_page, save_cookie, save_user_agent
+from .client import BASE_URL, HipdaClient, HipdaClientError
+from .parser import is_login_required_page, parse_forum_listing, parse_thread
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="hipda", description="Read 4D4Y/HiPDA forum posts from the terminal.")
+    parser.add_argument("--cookie", help="Logged-in Cookie header. Defaults to HIPDA_COOKIE.")
+    parser.add_argument("--user-agent", help="User-Agent header. Defaults to HIPDA_USER_AGENT or Chrome-like UA.")
+    parser.add_argument("--ca-file", help="PEM CA bundle to trust for HTTPS. Defaults to HIPDA_CA_FILE.")
+    parser.add_argument(
+        "--insecure-tls",
+        action="store_true",
+        help="Disable HTTPS certificate verification. This is the default for 4D4Y.",
+    )
+    parser.add_argument(
+        "--verify-tls",
+        action="store_true",
+        help="Enable HTTPS certificate verification.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", metavar="{login,list,read}")
+
+    subparsers.add_parser("login", help="Import 4D4Y login cookies from Chrome.")
+
+    list_parser = subparsers.add_parser("list", help="List Discovery threads.")
+    list_parser.add_argument("--page", type=int, default=1, help="Forum page number.")
+    list_parser.add_argument("--limit", type=int, default=30, help="Maximum number of threads to print.")
+
+    read_parser = subparsers.add_parser("read", help="Read a thread by tid or URL.")
+    read_parser.add_argument("thread", help="Thread id, or a full viewthread.php URL.")
+    read_parser.add_argument("--page", type=int, default=1, help="Thread page number.")
+
+    auth = subparsers.add_parser("auth", help=argparse.SUPPRESS)
+    auth_subparsers = auth.add_subparsers(dest="auth_command", required=True)
+    save_cookie_parser = auth_subparsers.add_parser("save-cookie", help="Save a pasted 4D4Y Cookie header.")
+    save_cookie_parser.add_argument("cookie", nargs="?", help="Cookie header value. Reads stdin if omitted.")
+    save_user_agent_parser = auth_subparsers.add_parser("save-user-agent", help="Save the Chrome User-Agent used with the cookie.")
+    save_user_agent_parser.add_argument("user_agent", nargs="?", help="User-Agent value. Reads stdin if omitted.")
+
+    discovery = subparsers.add_parser("discovery", help=argparse.SUPPRESS)
+    discovery_subparsers = discovery.add_subparsers(dest="discovery_command", required=True)
+
+    list_parser = discovery_subparsers.add_parser("list", help="List Discovery threads.")
+    list_parser.add_argument("--page", type=int, default=1, help="Forum page number.")
+    list_parser.add_argument("--limit", type=int, default=30, help="Maximum number of threads to print.")
+
+    read_parser = discovery_subparsers.add_parser("read", help="Read a thread by tid or URL.")
+    read_parser.add_argument("thread", help="Thread id, or a full viewthread.php URL.")
+    read_parser.add_argument("--page", type=int, default=1, help="Thread page number.")
+
+    subparsers._choices_actions = [
+        action for action in subparsers._choices_actions if action.dest not in {"auth", "discovery"}
+    ]
+
+    return parser
+
+
+def _thread_params(thread: str, page: int) -> dict[str, str | int]:
+    if "tid=" in thread:
+        tid = thread.split("tid=", 1)[1].split("&", 1)[0]
+    else:
+        tid = thread
+    return {"tid": tid, "page": page}
+
+
+def load_discovery_page(
+    *,
+    page: int,
+    path: str,
+    params: dict[str, str | int],
+    cookie: str | None,
+    user_agent: str | None,
+    ca_file: str | None,
+    insecure_tls: bool,
+    verify_tls: bool = False,
+) -> tuple[str, HipdaClient]:
+    client = HipdaClient.from_env(
+        cookie=cookie,
+        user_agent=user_agent,
+        ca_file=ca_file,
+        insecure_tls=insecure_tls or not verify_tls,
+        verify_tls=verify_tls,
+    )
+    html = client.get(path, params)
+    if not is_login_required_page(html):
+        return html, client
+
+    if cookie:
+        return html, client
+
+    try:
+        imported_cookie, imported_user_agent = import_browser_auth()
+    except Exception:
+        return html, client
+
+    client = HipdaClient.from_env(
+        cookie=imported_cookie,
+        user_agent=user_agent or imported_user_agent,
+        ca_file=ca_file,
+        insecure_tls=insecure_tls or not verify_tls,
+        verify_tls=verify_tls,
+    )
+    return client.get(path, params), client
+
+
+def wait_for_login_confirmation() -> None:
+    if sys.stdin.isatty():
+        input("Log in to 4D4Y in Chrome, then press Enter here...")
+
+
+def run(args: argparse.Namespace) -> int:
+    if args.command == "login":
+        try:
+            open_login_page()
+            wait_for_login_confirmation()
+            import_browser_auth()
+        except Exception as exc:
+            print(
+                "hipda: could not import 4D4Y cookies from Chrome. "
+                "Open Chrome, log in to https://www.4d4y.com/forum/forumdisplay.php?fid=2, then run `hipda login` again.",
+                file=sys.stderr,
+            )
+            print(f"hipda: {exc}", file=sys.stderr)
+            return 2
+        print("Imported 4D4Y login from Chrome.")
+        return 0
+
+    if args.command == "auth" and args.auth_command == "save-cookie":
+        cookie = args.cookie if args.cookie is not None else sys.stdin.read()
+        try:
+            path = save_cookie(cookie)
+        except ValueError as exc:
+            print(f"hipda: {exc}", file=sys.stderr)
+            return 2
+        print(f"Saved cookie to {path}")
+        return 0
+
+    if args.command == "auth" and args.auth_command == "save-user-agent":
+        user_agent = args.user_agent if args.user_agent is not None else sys.stdin.read()
+        try:
+            path = save_user_agent(user_agent)
+        except ValueError as exc:
+            print(f"hipda: {exc}", file=sys.stderr)
+            return 2
+        print(f"Saved user-agent to {path}")
+        return 0
+
+    client = HipdaClient.from_env(
+        cookie=args.cookie,
+        user_agent=args.user_agent,
+        ca_file=args.ca_file,
+        insecure_tls=args.insecure_tls or not args.verify_tls,
+        verify_tls=args.verify_tls,
+    )
+
+    try:
+        command = args.discovery_command if args.command == "discovery" else args.command
+
+        if command == "list":
+            html, client = load_discovery_page(
+                page=args.page,
+                path="forumdisplay.php",
+                params={"fid": 2, "page": args.page},
+                cookie=args.cookie,
+                user_agent=args.user_agent,
+                ca_file=args.ca_file,
+                insecure_tls=args.insecure_tls or not args.verify_tls,
+                verify_tls=args.verify_tls,
+            )
+            if is_login_required_page(html):
+                print(
+                    "hipda: 4D4Y says this request is not logged in. "
+                    "Open Chrome, log in to 4D4Y, then run `hipda login`.",
+                    file=sys.stderr,
+                )
+                return 2
+            threads = parse_forum_listing(html, base_url=BASE_URL)[: args.limit]
+            for thread in threads:
+                stats = ""
+                if thread.replies is not None and thread.views is not None:
+                    stats = f" {thread.replies}/{thread.views}"
+                last = f" last: {thread.last_author} {thread.last_at}".rstrip() if thread.last_author else ""
+                print(f"{thread.tid}\t{thread.title}\t{thread.author} {thread.created_at}{stats}{last}")
+            return 0
+
+        if command == "read":
+            html, client = load_discovery_page(
+                page=args.page,
+                path="viewthread.php",
+                params=_thread_params(args.thread, args.page),
+                cookie=args.cookie,
+                user_agent=args.user_agent,
+                ca_file=args.ca_file,
+                insecure_tls=args.insecure_tls or not args.verify_tls,
+                verify_tls=args.verify_tls,
+            )
+            if is_login_required_page(html):
+                print(
+                    "hipda: 4D4Y says this request is not logged in. "
+                    "Open Chrome, log in to 4D4Y, then run `hipda login`.",
+                    file=sys.stderr,
+                )
+                return 2
+            posts = parse_thread(html)
+            for index, post in enumerate(posts, start=1):
+                print(f"#{index} {post.author} {post.published_at}".rstrip())
+                print(post.content)
+                print()
+            return 0
+    except HipdaClientError as exc:
+        print(f"hipda: {exc}", file=sys.stderr)
+        if not client.cookie:
+            print("hipda: set HIPDA_COOKIE or pass --cookie with a logged-in 4D4Y Cookie header.", file=sys.stderr)
+        return 2
+
+    raise AssertionError(f"Unhandled command: {args}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    if argv is None:
+        argv = sys.argv[1:]
+    if not argv:
+        parser.print_help()
+        return 0
+    return run(parser.parse_args(argv))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hipda_cli/client.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import os
+import ssl
+from dataclasses import dataclass
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from .auth import load_cookie, load_user_agent
+
+
+BASE_URL = "https://www.4d4y.com/forum/"
+DEFAULT_USER_AGENT = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36"
+)
+
+
+class HipdaClientError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class HipdaClient:
+    cookie: str = ""
+    user_agent: str = DEFAULT_USER_AGENT
+    ca_file: str | None = None
+    insecure_tls: bool = True
+    base_url: str = BASE_URL
+    timeout: float = 20.0
+
+    @classmethod
+    def from_env(
+        cls,
+        cookie: str | None = None,
+        user_agent: str | None = None,
+        ca_file: str | None = None,
+        insecure_tls: bool = True,
+        verify_tls: bool = False,
+    ) -> "HipdaClient":
+        return cls(
+            cookie=cookie or os.environ.get("HIPDA_COOKIE", "") or load_cookie(),
+            user_agent=user_agent or os.environ.get("HIPDA_USER_AGENT", "") or load_user_agent() or DEFAULT_USER_AGENT,
+            ca_file=ca_file or os.environ.get("HIPDA_CA_FILE"),
+            insecure_tls=(
+                not verify_tls
+                and (insecure_tls or os.environ.get("HIPDA_INSECURE_TLS", "").lower() in {"1", "true", "yes"})
+            ),
+        )
+
+    def ssl_context(self) -> ssl.SSLContext | None:
+        if self.insecure_tls:
+            context = ssl.create_default_context()
+            context.check_hostname = False
+            context.verify_mode = ssl.CERT_NONE
+            return context
+        if self.ca_file:
+            return ssl.create_default_context(cafile=self.ca_file)
+        return None
+
+    def get(self, path: str, params: dict[str, str | int] | None = None) -> str:
+        url = self.base_url + path
+        if params:
+            url = f"{url}?{urlencode(params)}"
+
+        headers = {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+            "User-Agent": self.user_agent,
+        }
+        if self.cookie:
+            headers["Cookie"] = self.cookie
+
+        try:
+            with urlopen(Request(url, headers=headers), timeout=self.timeout, context=self.ssl_context()) as response:
+                body = response.read()
+                encoding = response.headers.get_content_charset() or "utf-8"
+                return body.decode(encoding, errors="replace")
+        except HTTPError as exc:
+            body = exc.read().decode("utf-8", errors="replace")[:300]
+            raise HipdaClientError(f"HTTP {exc.code} fetching {url}: {body}") from exc
+        except URLError as exc:
+            if isinstance(exc.reason, ssl.SSLCertVerificationError):
+                raise HipdaClientError(
+                    f"Could not verify TLS certificate for {url}: {exc.reason}. "
+                    "If you use a trusted local proxy, pass --ca-file /path/to/root.pem. "
+                    "As a last resort, pass --insecure-tls."
+                ) from exc
+            raise HipdaClientError(f"Could not fetch {url}: {exc.reason}") from exc

hipda_cli/models.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ThreadSummary:
+    tid: str
+    title: str
+    url: str
+    author: str = ""
+    created_at: str = ""
+    replies: int | None = None
+    views: int | None = None
+    last_author: str = ""
+    last_at: str = ""
+
+
+@dataclass(frozen=True)
+class Post:
+    author: str
+    published_at: str
+    content: str
+

hipda_cli/parser.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import re
+from urllib.parse import parse_qs, urljoin, urlparse
+
+from bs4 import BeautifulSoup
+
+from .models import Post, ThreadSummary
+
+
+THREAD_RE = re.compile(r"(?:^|[?&])tid=(\d+)")
+WHITESPACE_RE = re.compile(r"[ \t\r\f\v]+")
+
+
+def clean_text(value: str) -> str:
+    lines = []
+    for line in value.replace("\xa0", " ").splitlines():
+        cleaned = WHITESPACE_RE.sub(" ", line).strip()
+        if cleaned:
+            lines.append(cleaned)
+    return "\n".join(lines)
+
+
+def _tid_from_href(href: str) -> str | None:
+    parsed = urlparse(href)
+    tid = parse_qs(parsed.query).get("tid", [None])[0]
+    if tid:
+        return tid
+    match = THREAD_RE.search(href)
+    return match.group(1) if match else None
+
+
+def _split_cell_lines(cell) -> list[str]:
+    return clean_text(cell.get_text("\n")).splitlines()
+
+
+def _parse_counts(value: str) -> tuple[int | None, int | None]:
+    match = re.search(r"(\d+)\s*/\s*(\d+)", value)
+    if not match:
+        return None, None
+    return int(match.group(1)), int(match.group(2))
+
+
+def parse_forum_listing(html: str, base_url: str) -> list[ThreadSummary]:
+    soup = BeautifulSoup(html, "html.parser")
+    threads: list[ThreadSummary] = []
+    seen: set[str] = set()
+
+    for anchor in soup.find_all("a", href=True):
+        href = anchor["href"]
+        if "viewthread.php" not in href:
+            continue
+
+        tid = _tid_from_href(href)
+        title = clean_text(anchor.get_text())
+        if not tid or not title or tid in seen:
+            continue
+
+        row = anchor.find_parent("tr")
+        author = created_at = last_author = last_at = ""
+        replies = views = None
+        if row:
+            cells = row.find_all(["td", "th"], recursive=False)
+            anchor_cell = anchor.find_parent(["td", "th"])
+            anchor_cell_index = cells.index(anchor_cell) if anchor_cell in cells else -1
+            trailing_cells = cells[anchor_cell_index + 1 :] if anchor_cell_index >= 0 else []
+            if trailing_cells:
+                author_lines = _split_cell_lines(trailing_cells[0])
+                author = author_lines[0] if author_lines else ""
+                created_at = author_lines[1] if len(author_lines) > 1 else ""
+            if len(trailing_cells) > 1:
+                replies, views = _parse_counts(clean_text(trailing_cells[1].get_text(" ")))
+            if len(trailing_cells) > 2:
+                last_lines = _split_cell_lines(trailing_cells[2])
+                last_author = last_lines[0] if last_lines else ""
+                last_at = last_lines[1] if len(last_lines) > 1 else ""
+
+        seen.add(tid)
+        threads.append(
+            ThreadSummary(
+                tid=tid,
+                title=title,
+                url=urljoin(base_url, href),
+                author=author,
+                created_at=created_at,
+                replies=replies,
+                views=views,
+                last_author=last_author,
+                last_at=last_at,
+            )
+        )
+
+    return threads
+
+
+def is_login_required_page(html: str) -> bool:
+    text = clean_text(BeautifulSoup(html, "html.parser").get_text("\n"))
+    return "您还未登录" in text or "无权访问该版块" in text
+
+
+def parse_thread(html: str) -> list[Post]:
+    soup = BeautifulSoup(html, "html.parser")
+    posts: list[Post] = []
+
+    for container in soup.find_all(id=re.compile(r"^post_\d+")):
+        message = container.select_one(".t_msgfont") or container.select_one("[id^=postmessage_]")
+        if not message:
+            continue
+
+        author_node = container.select_one(".postauthor > .postinfo a") or container.select_one(".postauthor a")
+        if not author_node:
+            fallback_author_node = container.select_one(".postauthor")
+            if fallback_author_node and fallback_author_node.name != "td":
+                author_node = fallback_author_node
+        info_node = (
+            container.select_one(".authorinfo [id^=authorposton]")
+            or container.select_one(".postcontent .postinfo")
+            or container.select_one(".postinfo")
+        )
+        info_text = clean_text(info_node.get_text("\n")) if info_node else ""
+        published_at = re.sub(r"^发表于\s*", "", info_text.splitlines()[0]).strip() if info_text else ""
+
+        posts.append(
+            Post(
+                author=clean_text(author_node.get_text()) if author_node else "",
+                published_at=published_at,
+                content=clean_text(message.get_text("\n")),
+            )
+        )
+
+    return posts