daochu 0.1.0__tar.gz

daochu-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 DaoChu Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

daochu-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: daochu
+Version: 0.1.0
+Summary: 导出微信聊天记录为 HTML / Markdown — Export WeChat conversations to HTML or Markdown
+Author-email: DaoChu Contributors <daochu@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/daochu/daochu
+Project-URL: Repository, https://github.com/daochu/daochu
+Keywords: wechat,export,chat,html,markdown,backup
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Communications :: Chat
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: jinja2>=3.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# DaoChu（导出）
+
+[![PyPI version](https://img.shields.io/pypi/v/daochu.svg)](https://pypi.org/project/daochu/)
+[![Python](https://img.shields.io/pypi/pyversions/daochu.svg)](https://pypi.org/project/daochu/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**DaoChu**（导出）是一个 Python 命令行工具，能将微信聊天记录导出为精美的 **HTML** 页面或 **Markdown** 文件。
+
+> 支持解密后的微信 SQLite 数据库、CSV 导出、JSON 导出三种数据源。
+
+---
+
+## ✨ 特性
+
+- 🎨 **精美 HTML 输出** — 仿微信气泡样式，带日期分组、响应式设计
+- 📝 **Markdown 输出** — 纯文本，适合归档或导入笔记工具
+- 🔍 **自动联系人发现** — `list-contacts` 命令快速查看所有联系人
+- 🧠 **智能解析** — 自动识别文件类型（.db / .csv / .json）
+- 🖼️ **媒体标注** — 图片、语音、视频、链接等自动标注为可读文本
+
+---
+
+## 📦 安装
+
+```bash
+pip install daochu
+```
+
+要求 Python ≥ 3.10。
+
+---
+
+## 🚀 快速开始
+
+### 1. 列出联系人
+
+```bash
+daochu list-contacts /path/to/decrypted/MSG.db
+```
+
+### 2. 导出聊天记录
+
+```bash
+# 导出为 HTML（默认）
+daochu export MSG.db "wxid_abc123"
+
+# 导出为 Markdown
+daochu export MSG.db "wxid_abc123" -f md
+
+# 指定输出路径
+daochu export MSG.db "wxid_abc123" -o ~/Desktop/chat.html
+
+# 自定义自己的显示名
+daochu export MSG.db "wxid_abc123" --me "小明"
+```
+
+---
+
+## 📂 数据源说明
+
+| 类型 | 说明 |
+|------|------|
+| **SQLite (.db)** | 解密后的微信 Msg 数据库，最常见的方式 |
+| **CSV (.csv)** | 从第三方工具导出的 CSV，需含 timestamp/sender/content 列 |
+| **JSON (.json)** | 消息对象数组，格式 `[{timestamp, sender, content}]` |
+
+> **如何获取解密数据库？** 微信数据库默认加密存储在 `Documents/WeChat Files/<wxid>/Msg/` 下。可使用开源工具解密后配合 DaoChu 使用。
+
+---
+
+## 🖥️ 命令行参考
+
+```
+Usage: daochu [OPTIONS] COMMAND [ARGS]...
+
+Commands:
+  export          导出与某个联系人的全部聊天记录
+  list-contacts   列出数据库中的所有联系人
+
+export 选项:
+  -o, --output PATH        输出目录或文件路径
+  -f, --format [html|md]   输出格式
+  --me TEXT                自己的显示名称
+  --source-type [auto|db|csv|json]
+  --table TEXT             数据库表名
+  --encoding TEXT          文件编码
+```
+
+---
+
+## 🐍 Python API
+
+```python
+from daochu.parser import parse_db
+from daochu.exporter import export
+
+conv = parse_db("MSG0.db", "wxid_abc123", my_name="我")
+export(conv, "output.html", fmt="html")
+```
+
+---
+
+## 🖼️ 效果预览
+
+HTML 输出效果：
+
+- 顶部：联系人名称、日期范围、消息总数
+- 每一条消息：微信风格气泡，自己的消息靠右显示为绿色
+- 日期分组：按天自动插入日期分隔线
+- 移动端适配：响应式设计，手机上也能流畅阅读
+
+---
+
+## 📄 License
+
+MIT © DaoChu Contributors

daochu-0.1.0/README.md

@@ -0,0 +1,116 @@
+# DaoChu（导出）
+
+[![PyPI version](https://img.shields.io/pypi/v/daochu.svg)](https://pypi.org/project/daochu/)
+[![Python](https://img.shields.io/pypi/pyversions/daochu.svg)](https://pypi.org/project/daochu/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**DaoChu**（导出）是一个 Python 命令行工具，能将微信聊天记录导出为精美的 **HTML** 页面或 **Markdown** 文件。
+
+> 支持解密后的微信 SQLite 数据库、CSV 导出、JSON 导出三种数据源。
+
+---
+
+## ✨ 特性
+
+- 🎨 **精美 HTML 输出** — 仿微信气泡样式，带日期分组、响应式设计
+- 📝 **Markdown 输出** — 纯文本，适合归档或导入笔记工具
+- 🔍 **自动联系人发现** — `list-contacts` 命令快速查看所有联系人
+- 🧠 **智能解析** — 自动识别文件类型（.db / .csv / .json）
+- 🖼️ **媒体标注** — 图片、语音、视频、链接等自动标注为可读文本
+
+---
+
+## 📦 安装
+
+```bash
+pip install daochu
+```
+
+要求 Python ≥ 3.10。
+
+---
+
+## 🚀 快速开始
+
+### 1. 列出联系人
+
+```bash
+daochu list-contacts /path/to/decrypted/MSG.db
+```
+
+### 2. 导出聊天记录
+
+```bash
+# 导出为 HTML（默认）
+daochu export MSG.db "wxid_abc123"
+
+# 导出为 Markdown
+daochu export MSG.db "wxid_abc123" -f md
+
+# 指定输出路径
+daochu export MSG.db "wxid_abc123" -o ~/Desktop/chat.html
+
+# 自定义自己的显示名
+daochu export MSG.db "wxid_abc123" --me "小明"
+```
+
+---
+
+## 📂 数据源说明
+
+| 类型 | 说明 |
+|------|------|
+| **SQLite (.db)** | 解密后的微信 Msg 数据库，最常见的方式 |
+| **CSV (.csv)** | 从第三方工具导出的 CSV，需含 timestamp/sender/content 列 |
+| **JSON (.json)** | 消息对象数组，格式 `[{timestamp, sender, content}]` |
+
+> **如何获取解密数据库？** 微信数据库默认加密存储在 `Documents/WeChat Files/<wxid>/Msg/` 下。可使用开源工具解密后配合 DaoChu 使用。
+
+---
+
+## 🖥️ 命令行参考
+
+```
+Usage: daochu [OPTIONS] COMMAND [ARGS]...
+
+Commands:
+  export          导出与某个联系人的全部聊天记录
+  list-contacts   列出数据库中的所有联系人
+
+export 选项:
+  -o, --output PATH        输出目录或文件路径
+  -f, --format [html|md]   输出格式
+  --me TEXT                自己的显示名称
+  --source-type [auto|db|csv|json]
+  --table TEXT             数据库表名
+  --encoding TEXT          文件编码
+```
+
+---
+
+## 🐍 Python API
+
+```python
+from daochu.parser import parse_db
+from daochu.exporter import export
+
+conv = parse_db("MSG0.db", "wxid_abc123", my_name="我")
+export(conv, "output.html", fmt="html")
+```
+
+---
+
+## 🖼️ 效果预览
+
+HTML 输出效果：
+
+- 顶部：联系人名称、日期范围、消息总数
+- 每一条消息：微信风格气泡，自己的消息靠右显示为绿色
+- 日期分组：按天自动插入日期分隔线
+- 移动端适配：响应式设计，手机上也能流畅阅读
+
+---
+
+## 📄 License
+
+MIT © DaoChu Contributors

daochu-0.1.0/daochu/__init__.py

@@ -0,0 +1,20 @@
+"""
+DaoChu (导出) — Export WeChat conversations to HTML or Markdown.
+
+Usage:
+    daochu export <db_path> <contact> [--format html|md] [-o output]
+"""
+
+from .exporter import export, render_markdown
+from .parser import parse_csv, parse_db, parse_json
+from .templates import render_html
+
+__version__ = "0.1.0"
+__all__ = [
+    "export",
+    "parse_db",
+    "parse_csv",
+    "parse_json",
+    "render_html",
+    "render_markdown",
+]

daochu-0.1.0/daochu/cli.py

@@ -0,0 +1,146 @@
+"""CLI for DaoChu — 微信聊天记录导出工具."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from . import __version__
+from .exporter import export
+from .parser import auto_parse, parse_csv, parse_db, parse_json
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(__version__, "-V", "--version", message="DaoChu %(version)s")
+def main():
+    """DaoChu（导出）— 将微信聊天记录导出为 HTML 或 Markdown。
+
+    支持三种数据源：
+    \b
+    1. 解密后的微信 SQLite 数据库（MSG.db）
+    2. CSV 导出文件
+    3. JSON 导出文件
+    """
+
+
+@main.command("export")
+@click.argument("source", type=click.Path(exists=True))
+@click.argument("contact")
+@click.option(
+    "-o", "--output", default=".",
+    type=click.Path(),
+    help="输出目录或文件路径（默认当前目录）",
+)
+@click.option(
+    "-f", "--format", "fmt",
+    type=click.Choice(["html", "md"]),
+    default="html",
+    help="输出格式 (默认 html)",
+)
+@click.option(
+    "--me", "my_name",
+    default="Me",
+    help="自己的显示名称 (默认 Me)",
+)
+@click.option(
+    "--source-type", "source_type",
+    type=click.Choice(["auto", "db", "csv", "json"]),
+    default="auto",
+    help="数据源类型 (默认 auto 自动检测)",
+)
+@click.option(
+    "--table",
+    default="MSG",
+    help="数据库表名 (默认 MSG，仅 db 模式)",
+)
+@click.option(
+    "--encoding",
+    default="utf-8-sig",
+    help="CSV/JSON 文件编码 (默认 utf-8-sig)",
+)
+def export_cmd(
+    source, contact, output, fmt, my_name, source_type, table, encoding
+):
+    """导出与某个联系人的全部聊天记录。
+
+    SOURCE: 数据文件路径（解密后的 .db / .csv / .json）\n
+    CONTACT: 联系人 wxid 或显示名
+    """
+    source_path = Path(source)
+
+    try:
+        if source_type == "auto":
+            conv = auto_parse(source_path, contact, my_name, table=table)
+        elif source_type == "db":
+            conv = parse_db(source_path, contact, my_name, table=table)
+        elif source_type == "csv":
+            conv = parse_csv(source_path, contact, my_name, encoding=encoding)
+        elif source_type == "json":
+            conv = parse_json(source_path, contact, my_name, encoding=encoding)
+        else:
+            click.echo(f"未知数据源类型: {source_type}", err=True)
+            sys.exit(1)
+    except Exception as e:
+        click.echo(f"❌ 解析失败: {e}", err=True)
+        sys.exit(1)
+
+    if not conv.messages:
+        click.echo(f"⚠ 未找到与 '{contact}' 的聊天记录。")
+        sys.exit(0)
+
+    export(conv, output, fmt)
+
+
+@main.command("list-contacts")
+@click.argument("source", type=click.Path(exists=True))
+def list_contacts(source):
+    """列出数据库中的所有联系人。
+
+    SOURCE: 解密后的微信 SQLite 数据库路径。
+    """
+    import sqlite3
+
+    conn = sqlite3.connect(str(source))
+    cur = conn.cursor()
+
+    # Find MSG table
+    cur.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    tables = [r[0] for r in cur.fetchall()]
+    msg_tables = [t for t in tables if "MSG" in t.upper()]
+
+    if not msg_tables:
+        click.echo("❌ 未找到消息表。", err=True)
+        conn.close()
+        sys.exit(1)
+
+    table = msg_tables[0]
+
+    # Try common contact column names
+    for col in ("StrTalker", "talker", "sender", "contact"):
+        try:
+            cur.execute(
+                f'SELECT DISTINCT {col}, COUNT(*) as cnt FROM "{table}" '
+                f"GROUP BY {col} ORDER BY cnt DESC"
+            )
+            rows = cur.fetchall()
+            if rows:
+                click.echo(f"\n📋 联系人列表 (来自 {table}.{col})：\n")
+                click.echo(f"{'联系人 wxid/名称':<40} {'消息数':>8}")
+                click.echo("-" * 52)
+                for name, cnt in rows:
+                    name_str = str(name)[:38]
+                    click.echo(f"{name_str:<40} {cnt:>8}")
+                click.echo("")
+                break
+        except sqlite3.OperationalError:
+            continue
+    else:
+        click.echo("❌ 无法识别联系人列。请手动指定。", err=True)
+
+    conn.close()
+
+
+if __name__ == "__main__":
+    main()

daochu-0.1.0/daochu/exporter.py

@@ -0,0 +1,94 @@
+"""Export a Conversation to HTML or Markdown."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from .models import Conversation
+from .templates import render_html
+
+
+def render_markdown(conv: Conversation) -> str:
+    """Render a Conversation to Markdown."""
+    lines: list[str] = []
+    lines.append(f"# 💬 与 {conv.contact_name} 的微信聊天记录")
+    lines.append("")
+
+    if conv.messages:
+        first = conv.messages[0].date_str
+        last = conv.messages[-1].date_str
+        lines.append(f"> 📅 {first} — {last}  ·  📝 {conv.message_count} 条消息")
+    lines.append("")
+    lines.append("---")
+    lines.append("")
+
+    for date, msgs in conv.group_by_date():
+        lines.append(f"### {date}")
+        lines.append("")
+        for m in msgs:
+            role = conv.my_name if m.is_self else m.sender_name
+            time_str = m.short_time
+            content = m.content.replace("\n", "\n> ")
+            lines.append(f"**{role}** _{time_str}_")
+            lines.append(f"> {content}")
+            lines.append("")
+        lines.append("")
+
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+    lines.append("---")
+    lines.append(f"*由 [DaoChu](https://pypi.org/project/daochu/) 导出 · {now}*")
+
+    return "\n".join(lines)
+
+
+def export(
+    conv: Conversation,
+    output_path: str | Path,
+    fmt: str = "html",
+) -> Path:
+    """
+    Export a conversation to a file.
+
+    Parameters
+    ----------
+    conv : Conversation
+        The parsed conversation.
+    output_path : str | Path
+        Destination file path (auto-suffixed if it's a directory).
+    fmt : str
+        ``"html"`` or ``"md"`` / ``"markdown"``.
+
+    Returns
+    -------
+    Path
+        The path of the written file.
+    """
+    output_path = Path(output_path)
+
+    if output_path.is_dir() or output_path.suffix not in (".html", ".md", ".markdown"):
+        safe_name = _safe_filename(conv.contact_name)
+        suffix = ".html" if fmt == "html" else ".md"
+        output_path = output_path / f"{safe_name}_chat{suffix}"
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    now_str = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+    if fmt in ("md", "markdown"):
+        content = render_markdown(conv)
+    else:
+        content = render_html(conv, now_str)
+
+    output_path.write_text(content, encoding="utf-8")
+    print(f"✅ 导出成功 → {output_path}  ({conv.message_count} 条消息)")
+    return output_path
+
+
+def _safe_filename(name: str) -> str:
+    """Sanitize a name for use as a filename."""
+    unsafe = r'<>:"/\|?*'
+    safe = name
+    for ch in unsafe:
+        safe = safe.replace(ch, "_")
+    return safe.strip()

daochu-0.1.0/daochu/models.py

@@ -0,0 +1,61 @@
+"""Data models for WeChat messages and conversations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class Message:
+    """A single WeChat message."""
+
+    id: int
+    timestamp: datetime
+    sender_name: str        # who sent it
+    content: str            # text content
+    msg_type: int = 1       # 1=text, 3=image, 34=voice, 47=emoji, etc.
+    is_self: bool = False   # sent by the account owner
+
+    @property
+    def formatted_time(self) -> str:
+        return self.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+
+    @property
+    def short_time(self) -> str:
+        return self.timestamp.strftime("%H:%M")
+
+    @property
+    def date_str(self) -> str:
+        return self.timestamp.strftime("%Y-%m-%d")
+
+
+@dataclass
+class Conversation:
+    """A conversation with a specific contact."""
+
+    contact_name: str
+    messages: list[Message] = field(default_factory=list)
+    my_name: str = "Me"
+
+    @property
+    def date_range(self) -> tuple[str, str]:
+        if not self.messages:
+            return ("", "")
+        first = self.messages[0].date_str
+        last = self.messages[-1].date_str
+        return (first, last)
+
+    @property
+    def message_count(self) -> int:
+        return len(self.messages)
+
+    def group_by_date(self) -> list[tuple[str, list[Message]]]:
+        """Group messages by date, returns [(date_str, [msg, ...]), ...]."""
+        groups: list[tuple[str, list[Message]]] = []
+        for msg in self.messages:
+            if not groups or groups[-1][0] != msg.date_str:
+                groups.append((msg.date_str, []))
+            groups[-1][1].append(msg)
+        return groups

daochu-0.1.0/daochu/parser.py

@@ -0,0 +1,292 @@
+"""Parser: read WeChat messages from SQLite database or CSV/JSON exports."""
+
+from __future__ import annotations
+
+import csv
+import json
+import sqlite3
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from .models import Conversation, Message
+
+
+# ── SQLite (decrypted WeChat DB) ────────────────────────────────────────────
+
+def _try_parse_ts(val) -> Optional[datetime]:
+    """WeChat uses Unix timestamps (seconds or milliseconds)."""
+    if val is None:
+        return None
+    try:
+        n = int(val)
+        if n > 1_000_000_000_000:  # milliseconds
+            n //= 1000
+        return datetime.fromtimestamp(n)
+    except (ValueError, OSError):
+        return None
+
+
+def parse_db(
+    db_path: str | Path,
+    contact_name: str,
+    my_name: str = "Me",
+    *,
+    contact_col: str = "StrTalker",
+    content_col: str = "StrContent",
+    time_col: str = "CreateTime",
+    type_col: str = "Type",
+    is_sender_col: str = "IsSender",
+    table: str = "MSG",
+) -> Conversation:
+    """
+    Parse a decrypted WeChat Msg database.
+
+    Parameters
+    ----------
+    db_path : str | Path
+        Path to the decrypted SQLite database (e.g. ``MSG0.db``).
+    contact_name : str
+        The wxid or display name of the contact whose conversation to export.
+    my_name : str
+        How to label your own messages (default "Me").
+    contact_col, content_col, time_col, type_col, is_sender_col, table :
+        Column / table names; defaults work for common WeChat versions.
+    """
+    db_path = Path(db_path)
+    if not db_path.exists():
+        raise FileNotFoundError(f"Database not found: {db_path}")
+
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    # Determine the actual table name
+    cur.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    tables = [r["name"] for r in cur.fetchall()]
+    if table not in tables:
+        # Try to find a suitable table
+        candidates = [t for t in tables if "MSG" in t.upper()]
+        if candidates:
+            table = candidates[0]
+        else:
+            raise ValueError(
+                f"Table '{table}' not found. Available tables: {tables}"
+            )
+
+    # Determine columns
+    cur.execute(f"PRAGMA table_info('{table}')")
+    cols = {r["name"].lower(): r["name"] for r in cur.fetchall()}
+
+    def _col(key: str) -> str:
+        return cols.get(key.lower(), key)
+
+    # Query messages for this contact (sorted by time)
+    try:
+        cur.execute(
+            f'SELECT * FROM "{table}" WHERE {_col(contact_col)} = ? ORDER BY {_col(time_col)} ASC',
+            (contact_name,),
+        )
+    except sqlite3.OperationalError as e:
+        # Maybe the contact is stored in another column
+        raise RuntimeError(
+            f"Failed to query table '{table}'. Tried contact column '{contact_col}'. "
+            f"Available columns: {list(cols.values())}. Error: {e}"
+        )
+
+    rows = cur.fetchall()
+    conn.close()
+
+    messages: list[Message] = []
+    for row in rows:
+        ts = _try_parse_ts(row[_col(time_col)])
+        content = row[_col(content_col)] or ""
+        msg_type = int(row[_col(type_col)] or 1)
+
+        # Determine if self-sent
+        is_self = False
+        raw_is_sender = row[_col(is_sender_col)]
+        if raw_is_sender is not None:
+            is_self = bool(int(raw_is_sender))
+
+        # Skip non-text system messages
+        if msg_type == 10000:  # system message
+            continue
+
+        # Format non-text messages
+        if msg_type != 1:
+            content = _format_media(content, msg_type)
+
+        messages.append(Message(
+            id=row.get("localId", row.get("msgId", len(messages))),
+            timestamp=ts or datetime.now(),
+            sender_name=my_name if is_self else contact_name,
+            content=content,
+            msg_type=msg_type,
+            is_self=is_self,
+        ))
+
+    if not messages:
+        print(f"⚠ No messages found for contact '{contact_name}' in table '{table}'.")
+
+    return Conversation(contact_name=contact_name, messages=messages, my_name=my_name)
+
+
+def _format_media(content: str, msg_type: int) -> str:
+    """Replace binary/media placeholders with readable labels."""
+    type_labels = {
+        3:  "[图片]",
+        34: "[语音]",
+        43: "[视频]",
+        47: "[表情]",
+        49: "[链接/文件]",
+        10000: "[系统消息]",
+        10002: "[群系统消息]",
+    }
+    label = type_labels.get(msg_type, f"[消息类型:{msg_type}]")
+
+    # Try to extract useful text from XML content
+    if msg_type == 49 and content:
+        title = re.search(r"<title>(.*?)</title>", content)
+        if title:
+            label = f"[链接] {title.group(1)}"
+        desc = re.search(r"<des>(.*?)</des>", content)
+        if desc:
+            label += f"\n{desc.group(1)}"
+
+    return f"{label}"
+
+
+# ── CSV 导出 ─────────────────────────────────────────────────────────────────
+
+def parse_csv(
+    csv_path: str | Path,
+    contact_name: str,
+    my_name: str = "Me",
+    *,
+    encoding: str = "utf-8-sig",
+) -> Conversation:
+    """
+    Parse a CSV export with columns: timestamp, sender, content[, type].
+
+    The CSV can be exported by tools like 微信聊天记录导出 or similar.
+    """
+    csv_path = Path(csv_path)
+    if not csv_path.exists():
+        raise FileNotFoundError(f"CSV file not found: {csv_path}")
+
+    messages: list[Message] = []
+    with open(csv_path, encoding=encoding, newline="") as f:
+        reader = csv.DictReader(f)
+        for i, row in enumerate(reader):
+            # try common column names
+            ts_str = row.get("timestamp") or row.get("time") or row.get("CreateTime") or ""
+            sender = row.get("sender") or row.get("talker") or row.get("StrTalker") or ""
+            content = row.get("content") or row.get("message") or row.get("StrContent") or ""
+            msg_type = int(row.get("type") or row.get("Type") or 1)
+
+            ts = _try_parse_ts(ts_str)
+            if ts is None:
+                try:
+                    ts = datetime.strptime(ts_str, "%Y-%m-%d %H:%M:%S")
+                except ValueError:
+                    ts = datetime.now()
+
+            is_self = sender.strip().lower() in (my_name.lower(), "me", "1", "true")
+            if is_self:
+                display_sender = my_name
+            else:
+                display_sender = sender.strip()
+
+            content = content or ""
+            if msg_type != 1:
+                content = _format_media(content, msg_type)
+
+            messages.append(Message(
+                id=i,
+                timestamp=ts,
+                sender_name=display_sender,
+                content=content,
+                msg_type=msg_type,
+                is_self=is_self,
+            ))
+
+    return Conversation(contact_name=contact_name, messages=messages, my_name=my_name)
+
+
+# ── JSON 导出 ─────────────────────────────────────────────────────────────────
+
+def parse_json(
+    json_path: str | Path,
+    contact_name: str,
+    my_name: str = "Me",
+    *,
+    encoding: str = "utf-8",
+) -> Conversation:
+    """
+    Parse a JSON export (list of message objects).
+
+    Each object should have: timestamp (or time), sender (or talker), content (or message).
+    """
+    json_path = Path(json_path)
+    if not json_path.exists():
+        raise FileNotFoundError(f"JSON file not found: {json_path}")
+
+    data = json.loads(json_path.read_text(encoding=encoding))
+    if isinstance(data, dict):
+        data = data.get("messages") or data.get("data") or []
+
+    messages: list[Message] = []
+    for i, obj in enumerate(data):
+        ts_str = obj.get("timestamp") or obj.get("time") or obj.get("CreateTime") or ""
+        sender = obj.get("sender") or obj.get("talker") or obj.get("StrTalker") or ""
+        content = obj.get("content") or obj.get("message") or obj.get("StrContent") or ""
+        msg_type = int(obj.get("type") or obj.get("Type") or 1)
+
+        ts = _try_parse_ts(ts_str)
+        if ts is None:
+            try:
+                ts = datetime.strptime(str(ts_str), "%Y-%m-%d %H:%M:%S")
+            except ValueError:
+                ts = datetime.now()
+
+        is_self = str(sender).strip().lower() in (my_name.lower(), "me", "1", "true")
+        display_sender = my_name if is_self else str(sender).strip()
+
+        if msg_type != 1:
+            content = _format_media(content, msg_type)
+
+        messages.append(Message(
+            id=i,
+            timestamp=ts,
+            sender_name=display_sender,
+            content=content,
+            msg_type=msg_type,
+            is_self=is_self,
+        ))
+
+    return Conversation(contact_name=contact_name, messages=messages, my_name=my_name)
+
+
+# ── Auto-detect ──────────────────────────────────────────────────────────────
+
+def auto_parse(
+    path: str | Path,
+    contact_name: str,
+    my_name: str = "Me",
+    **kwargs,
+) -> Conversation:
+    """Auto-detect file type and parse accordingly."""
+    path = Path(path)
+    suffix = path.suffix.lower()
+
+    if suffix in (".db", ".sqlite", ".sqlite3", ""):
+        return parse_db(path, contact_name, my_name, **kwargs)
+    elif suffix == ".csv":
+        return parse_csv(path, contact_name, my_name, **kwargs)
+    elif suffix == ".json":
+        return parse_json(path, contact_name, my_name, **kwargs)
+    else:
+        # try as db first
+        return parse_db(path, contact_name, my_name, **kwargs)

daochu-0.1.0/daochu/templates.py

@@ -0,0 +1,193 @@
+"""HTML template for WeChat conversation export."""
+
+HTML_TEMPLATE = r"""<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>与 {{ conv.contact_name }} 的微信聊天记录</title>
+<style>
+  :root {
+    --bg: #ededed;
+    --card-bg: #ffffff;
+    --bubble-self: #95ec69;
+    --bubble-other: #ffffff;
+    --text: #111;
+    --muted: #999;
+    --border: #d9d9d9;
+    --date-bg: #dcdcdc;
+  }
+  * { margin:0; padding:0; box-sizing:border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC",
+      "Microsoft YaHei", "Helvetica Neue", sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    line-height: 1.6;
+  }
+
+  /* ── header ── */
+  .header {
+    background: var(--card-bg);
+    padding: 32px 24px 24px;
+    text-align: center;
+    border-bottom: 1px solid var(--border);
+    position: sticky;
+    top: 0;
+    z-index: 10;
+    box-shadow: 0 1px 6px rgba(0,0,0,.06);
+  }
+  .header h1 { font-size: 1.4rem; font-weight: 600; margin-bottom: 4px; }
+  .header .meta { font-size: 0.85rem; color: var(--muted); }
+
+  /* ── container ── */
+  .container {
+    max-width: 680px;
+    margin: 0 auto;
+    padding: 16px 12px 48px;
+  }
+
+  /* ── date divider ── */
+  .date-divider {
+    text-align: center;
+    margin: 20px 0 12px;
+  }
+  .date-divider span {
+    display: inline-block;
+    background: var(--date-bg);
+    color: #666;
+    font-size: 0.75rem;
+    padding: 3px 12px;
+    border-radius: 3px;
+  }
+
+  /* ── message row ── */
+  .msg-row {
+    display: flex;
+    margin-bottom: 12px;
+    padding: 0 8px;
+  }
+  .msg-row.self { justify-content: flex-end; }
+  .msg-row.other { justify-content: flex-start; }
+
+  /* ── bubble ── */
+  .bubble {
+    max-width: 72%;
+    padding: 10px 14px;
+    border-radius: 8px;
+    font-size: 0.95rem;
+    word-break: break-word;
+    white-space: pre-wrap;
+    position: relative;
+    box-shadow: 0 1px 2px rgba(0,0,0,.06);
+  }
+  .self .bubble {
+    background: var(--bubble-self);
+    border-top-right-radius: 2px;
+  }
+  .other .bubble {
+    background: var(--bubble-other);
+    border: 1px solid var(--border);
+    border-top-left-radius: 2px;
+  }
+
+  /* ── sender label ── */
+  .sender-label {
+    font-size: 0.7rem;
+    color: var(--muted);
+    margin-bottom: 2px;
+    padding: 0 4px;
+  }
+  .self .sender-label { text-align: right; }
+
+  /* ── time ── */
+  .time-tag {
+    font-size: 0.65rem;
+    color: #b0b0b0;
+    margin-top: 4px;
+    text-align: right;
+  }
+
+  /* ── media tag ── */
+  .media-tag {
+    color: #5865a0;
+    font-style: italic;
+  }
+
+  /* ── footer ── */
+  .footer {
+    text-align: center;
+    padding: 24px;
+    color: var(--muted);
+    font-size: 0.78rem;
+  }
+  .footer a { color: var(--muted); }
+
+  /* ── stats bar ── */
+  .stats {
+    display: flex;
+    justify-content: center;
+    gap: 18px;
+    flex-wrap: wrap;
+    margin-top: 8px;
+    font-size: 0.8rem;
+    color: var(--muted);
+  }
+
+  @media (max-width: 480px) {
+    .container { padding: 8px 4px 40px; }
+    .bubble { max-width: 85%; font-size: 0.9rem; }
+    .header { padding: 20px 12px 16px; }
+  }
+</style>
+</head>
+<body>
+
+<div class="header">
+  <h1>💬 {{ conv.contact_name }}</h1>
+  <div class="meta">微信聊天记录</div>
+  <div class="stats">
+    {% if conv.messages %}
+    <span>📅 {{ conv.messages[0].date_str }} — {{ conv.messages[-1].date_str }}</span>
+    <span>📝 {{ conv.message_count }} 条消息</span>
+    {% endif %}
+  </div>
+</div>
+
+<div class="container">
+{% for date, msgs in conv.group_by_date() %}
+  <div class="date-divider"><span>{{ date }}</span></div>
+  {% for m in msgs %}
+  <div class="msg-row {{ 'self' if m.is_self else 'other' }}">
+    <div>
+      {% if not m.is_self %}
+      <div class="sender-label">{{ m.sender_name }}</div>
+      {% endif %}
+      <div class="bubble">
+        <span class="{{ 'media-tag' if m.msg_type != 1 else '' }}">{{ m.content }}</span>
+        <div class="time-tag">{{ m.short_time }}</div>
+      </div>
+    </div>
+  </div>
+  {% endfor %}
+{% endfor %}
+</div>
+
+<div class="footer">
+  <p>由 <a href="https://pypi.org/project/daochu/">DaoChu</a> 导出 · {{ now }}</p>
+</div>
+
+</body>
+</html>"""
+
+
+def render_html(conv, now_str: str = "") -> str:
+    """Render a Conversation to a complete HTML page."""
+    from jinja2 import Template
+    from datetime import datetime
+
+    tpl = Template(HTML_TEMPLATE)
+    return tpl.render(
+        conv=conv,
+        now=now_str or datetime.now().strftime("%Y-%m-%d %H:%M"),
+    )

daochu-0.1.0/daochu.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: daochu
+Version: 0.1.0
+Summary: 导出微信聊天记录为 HTML / Markdown — Export WeChat conversations to HTML or Markdown
+Author-email: DaoChu Contributors <daochu@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/daochu/daochu
+Project-URL: Repository, https://github.com/daochu/daochu
+Keywords: wechat,export,chat,html,markdown,backup
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Communications :: Chat
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: jinja2>=3.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# DaoChu（导出）
+
+[![PyPI version](https://img.shields.io/pypi/v/daochu.svg)](https://pypi.org/project/daochu/)
+[![Python](https://img.shields.io/pypi/pyversions/daochu.svg)](https://pypi.org/project/daochu/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**DaoChu**（导出）是一个 Python 命令行工具，能将微信聊天记录导出为精美的 **HTML** 页面或 **Markdown** 文件。
+
+> 支持解密后的微信 SQLite 数据库、CSV 导出、JSON 导出三种数据源。
+
+---
+
+## ✨ 特性
+
+- 🎨 **精美 HTML 输出** — 仿微信气泡样式，带日期分组、响应式设计
+- 📝 **Markdown 输出** — 纯文本，适合归档或导入笔记工具
+- 🔍 **自动联系人发现** — `list-contacts` 命令快速查看所有联系人
+- 🧠 **智能解析** — 自动识别文件类型（.db / .csv / .json）
+- 🖼️ **媒体标注** — 图片、语音、视频、链接等自动标注为可读文本
+
+---
+
+## 📦 安装
+
+```bash
+pip install daochu
+```
+
+要求 Python ≥ 3.10。
+
+---
+
+## 🚀 快速开始
+
+### 1. 列出联系人
+
+```bash
+daochu list-contacts /path/to/decrypted/MSG.db
+```
+
+### 2. 导出聊天记录
+
+```bash
+# 导出为 HTML（默认）
+daochu export MSG.db "wxid_abc123"
+
+# 导出为 Markdown
+daochu export MSG.db "wxid_abc123" -f md
+
+# 指定输出路径
+daochu export MSG.db "wxid_abc123" -o ~/Desktop/chat.html
+
+# 自定义自己的显示名
+daochu export MSG.db "wxid_abc123" --me "小明"
+```
+
+---
+
+## 📂 数据源说明
+
+| 类型 | 说明 |
+|------|------|
+| **SQLite (.db)** | 解密后的微信 Msg 数据库，最常见的方式 |
+| **CSV (.csv)** | 从第三方工具导出的 CSV，需含 timestamp/sender/content 列 |
+| **JSON (.json)** | 消息对象数组，格式 `[{timestamp, sender, content}]` |
+
+> **如何获取解密数据库？** 微信数据库默认加密存储在 `Documents/WeChat Files/<wxid>/Msg/` 下。可使用开源工具解密后配合 DaoChu 使用。
+
+---
+
+## 🖥️ 命令行参考
+
+```
+Usage: daochu [OPTIONS] COMMAND [ARGS]...
+
+Commands:
+  export          导出与某个联系人的全部聊天记录
+  list-contacts   列出数据库中的所有联系人
+
+export 选项:
+  -o, --output PATH        输出目录或文件路径
+  -f, --format [html|md]   输出格式
+  --me TEXT                自己的显示名称
+  --source-type [auto|db|csv|json]
+  --table TEXT             数据库表名
+  --encoding TEXT          文件编码
+```
+
+---
+
+## 🐍 Python API
+
+```python
+from daochu.parser import parse_db
+from daochu.exporter import export
+
+conv = parse_db("MSG0.db", "wxid_abc123", my_name="我")
+export(conv, "output.html", fmt="html")
+```
+
+---
+
+## 🖼️ 效果预览
+
+HTML 输出效果：
+
+- 顶部：联系人名称、日期范围、消息总数
+- 每一条消息：微信风格气泡，自己的消息靠右显示为绿色
+- 日期分组：按天自动插入日期分隔线
+- 移动端适配：响应式设计，手机上也能流畅阅读
+
+---
+
+## 📄 License
+
+MIT © DaoChu Contributors

daochu-0.1.0/daochu.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+daochu/__init__.py
+daochu/cli.py
+daochu/exporter.py
+daochu/models.py
+daochu/parser.py
+daochu/templates.py
+daochu.egg-info/PKG-INFO
+daochu.egg-info/SOURCES.txt
+daochu.egg-info/dependency_links.txt
+daochu.egg-info/entry_points.txt
+daochu.egg-info/requires.txt
+daochu.egg-info/top_level.txt

daochu-0.1.0/daochu.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

daochu-0.1.0/daochu.egg-info/entry_points.txt

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

daochu-0.1.0/daochu.egg-info/requires.txt

@@ -0,0 +1,6 @@
+click>=8.0
+jinja2>=3.0
+
+[dev]
+build>=1.0
+twine>=5.0

daochu-0.1.0/daochu.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+daochu
+dist

daochu-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "daochu"
+version = "0.1.0"
+description = "导出微信聊天记录为 HTML / Markdown — Export WeChat conversations to HTML or Markdown"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    {name = "DaoChu Contributors", email = "daochu@example.com"}
+]
+keywords = ["wechat", "export", "chat", "html", "markdown", "backup"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: End Users/Desktop",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Communications :: Chat",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.0",
+    "jinja2>=3.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "build>=1.0",
+    "twine>=5.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/daochu/daochu"
+Repository = "https://github.com/daochu/daochu"
+
+[project.scripts]
+daochu = "daochu.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

daochu-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+