# ❌ 错误：wiki + drive 同时请求会报 20043
scope = "wiki:wiki:read drive:drive:readonly"

# ✅ 正确：分开授权，先 wiki 后 drive
scope = "wiki:wiki:read"
# 第一次授权完，再发起一次 drive 的授权

import requests

headers = {"Authorization": f"Bearer {tenant_token}"}

# Step 1: 在根目录创建
resp = requests.post(
    f"https://open.feishu.cn/open-apis/wiki/v2/spaces/{space_id}/nodes",
    headers=headers,
    json={"obj_type": "docx", "node_type": "origin", "title": "新文档"}
)
new_node_token = resp.json()["data"]["node"]["node_token"]

# Step 2: 移动到目标目录
resp = requests.post(
    f"https://open.feishu.cn/open-apis/wiki/v2/spaces/{space_id}/nodes/{new_node_token}/move",
    headers=headers,
    json={
        "target_space_id": space_id,
        "target_parent_token": "目标目录的node_token"
    }
)

# 先通过 Wiki API 获取 node 信息，里面有 obj_token
node_info = requests.get(
    f"https://open.feishu.cn/open-apis/wiki/v2/spaces/{space_id}/nodes/{node_token}",
    headers=headers
).json()
obj_token = node_info["data"]["node"]["obj_token"]

# 再用 obj_token 调 Docx API
requests.put(
    f"https://open.feishu.cn/open-apis/docx/v1/documents/{obj_token}/blocks",
    headers=headers,
    json={"items": [...]}
)

import time

def batch_write_blocks(obj_token, blocks, headers, batch_size=5, interval=0.3):
    """分批写入文档内容"""
    for i in range(0, len(blocks), batch_size):
        batch = blocks[i:i + batch_size]
        resp = requests.put(
            f"https://open.feishu.cn/open-apis/docx/v1/documents/{obj_token}/blocks",
            headers=headers,
            json={"items": batch}
        ).json()

        if resp.get("code") != 0:
            raise Exception(f"写入失败: {resp}")

        time.sleep(interval)  # 关键：每批之间等 0.3 秒

def create_wiki_doc_with_content(space_id, parent_node_token, title, content_blocks, headers):
    """在指定 Wiki 目录创建文档并写入内容"""
    # 1. 先在根目录创建
    resp = requests.post(
        f"https://open.feishu.cn/open-apis/wiki/v2/spaces/{space_id}/nodes",
        headers=headers,
        json={"obj_type": "docx", "node_type": "origin", "title": title}
    ).json()
    if resp.get("code") != 0:
        raise Exception(f"创建文档失败: {resp}")
    node_token = resp["data"]["node"]["node_token"]

    # 2. 移动到目标目录
    if parent_node_token:
        resp = requests.post(
            f"https://open.feishu.cn/open-apis/wiki/v2/spaces/{space_id}/nodes/{node_token}/move",
            headers=headers,
            json={
                "target_space_id": space_id,
                "target_parent_token": parent_node_token
            }
        ).json()
        if resp.get("code") != 0:
            raise Exception(f"移动文档失败: {resp}")

    # 3. 获取 obj_token
    node_info = requests.get(
        f"https://open.feishu.cn/open-apis/wiki/v2/spaces/{space_id}/nodes/{node_token}",
        headers=headers
    ).json()
    obj_token = node_info["data"]["node"]["obj_token"]

    # 4. 分批写入内容
    batch_write_blocks(obj_token, content_blocks, headers)

    return {
        "node_token": node_token,
        "obj_token": obj_token,
        "url": f"https://feishu.cn/wiki/{node_token}"
    }


# 用法：创建一份今日日报
content_blocks = [
    {"block_type": 3, "heading2": {"elements": [{"text_run": {"content": "今日日报"}}]}},
    {"block_type": 22, "divider": {}},
    {"block_type": 2, "text": {"elements": [{"text_run": {"content": "AI 行业有 3 条重要新闻..."}}]}},
    {"block_type": 12, "bullet": {"elements": [{"text_run": {"content": "新闻 1"}}]}},
    {"block_type": 12, "bullet": {"elements": [{"text_run": {"content": "新闻 2"}}]}},
]

result = create_wiki_doc_with_content(
    space_id="7632282247265029317",
    parent_node_token="目标目录的node_token",
    title="2026-06-20 每日情报",
    content_blocks=content_blocks,
    headers={"Authorization": "Bearer xxx"}
)
print(f"文档创建成功: {result['url']}")

import requests
import re
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
}

MAGNET_RE = re.compile(r'magnet:\?xt=urn:btih:[a-zA-Z0-9]+', re.I)
FTP_RE = re.compile(r'ftp://[^\s"\'<>]+', re.I)

def scrape_level1(search_url, headers=None):
    """级别1：纯静态正则"""
    h = headers or HEADERS
    resp = requests.get(search_url, headers=h, timeout=15)

    # 老旧网站常用 GB2312 编码，必须显式声明
    if 'gb2312' in (resp.apparent_encoding or '').lower():
        resp.encoding = 'gb2312'

    html = resp.text

    # 一次性提取所有磁力和 FTP
    magnets = set(MAGNET_RE.findall(html))
    ftps = set(FTP_RE.findall(html))

    return list(magnets) + list(ftps)

import re

def extract_metadata(context_text):
    """从磁力链接的上下文文本提取元数据"""
    metadata = {}

    # 清晰度
    if res := re.search(r'\b(2160p|1080p|720p|4K)\b', context_text, re.I):
        metadata['resolution'] = res.group(1)

    # 格式
    if fmt := re.search(r'\b(BluRay|WEB-DL|HDTV|DVDRip|Remux|BDRip)\b', context_text, re.I):
        metadata['source'] = fmt.group(1)

    # 文件大小（GB/MB）
    if size := re.search(r'(\d+\.?\d*)\s*(GB|MB)', context_text, re.I):
        metadata['size'] = f"{size.group(1)} {size.group(2)}"

    return metadata

import base64

def scrape_level2(html):
    """级别2：从 JS 变量和隐藏 input 提取"""
    magnets = []

    # 1. 从 <input> value 提取
    soup = BeautifulSoup(html, 'html.parser')
    for inp in soup.find_all('input', type='hidden'):
        value = inp.get('value', '')
        if 'magnet:?' in value:
            magnets.append(value)

    # 2. 从 data-* 属性提取
    for elem in soup.find_all(attrs={'data-magnet': True}):
        magnets.append(elem['data-magnet'])

    # 3. 从 JS 变量 Base64 解码提取
    b64_pattern = re.compile(r'["\']([A-Za-z0-9+/=]{40,})["\']')
    for match in b64_pattern.findall(html):
        try:
            decoded = base64.b64decode(match).decode('utf-8', errors='ignore')
            if 'magnet:?' in decoded:
                # 再用级别1的正则提取
                magnets.extend(MAGNET_RE.findall(decoded))
        except Exception:
            continue

    return list(set(magnets))

from playwright.sync_api import sync_playwright

def scrape_level3(url):
    """级别3：Headless 浏览器模拟点击"""
    magnets = []

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        try:
            page = browser.new_page()
            page.goto(url, timeout=30000)
            page.wait_for_load_state('networkidle')

            # 模拟点击下载按钮
            page.click('a.download-btn', timeout=5000)
            page.wait_for_timeout(2000)  # 等 XHR 回来

            # 提取渲染后的 HTML
            html = page.content()
            magnets = MAGNET_RE.findall(html)

        finally:
            browser.close()  # 🔥 关键：必须 close，否则内存泄露

    return magnets

# ❌ 错误写法
async def scrape_many(urls):
    tasks = [scrape(url) for url in urls]
    await asyncio.gather(*tasks)  # 并发 5 个 Playwright 直接 OOM

# ✅ 正确写法
def scrape_many(urls):
    for url in urls:
        result = scrape_level3(url)
        # 串行执行，每个跑完立刻销毁

from DrissionPage import ChromiumPage, ChromiumOptions

def scrape_level4(url):
    """级别4：DrissionPage 破 CF 盾"""
    magnets = []

    options = ChromiumOptions()
    options.headless(True)

    page = None
    try:
        page = ChromiumPage(options)
        page.get(url, retry=3, timeout=30)

        # CF 盾通常需要 5-8 秒等待
        page.wait.load_start()

        # 等待页面正常加载（CF 挑战完成后页面会有变化）
        for _ in range(30):
            if 'just-a-moment' not in page.html.lower():
                break
            page.wait(1)

        magnets = MAGNET_RE.findall(page.html)
    finally:
        if page:
            page.quit()  # 🔥 关键：销毁 Chromium 内核进程

    return magnets

import requests

direct_session = requests.Session()
direct_session.trust_env = False  # 不读系统代理环境变量

CHUNK_SIZE = 5 * 1024 * 1024  # 5MB

import time

def upload_with_retry(session, url, data, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = session.put(url, data=data)
            if response.status_code in (200, 201, 202):
                return response
        except requests.exceptions.RequestException as e:
            print(f"上传失败 (第 {attempt+1} 次): {e}")

        # 退避：每次重试前多等一会
        time.sleep(3 + attempt)

    raise Exception(f"上传失败，已重试 {max_retries} 次")

import os
import tarfile
import requests
import time

ONEDRIVE_BACKUP_PATH = "backups/full_backup"
CHUNK_SIZE = 5 * 1024 * 1024  # 5MB

def create_backup_tar(source_dirs, output_file):
    """打包 + 排除垃圾"""
    excludes = [
        "*venv*",
        "*node_modules*",
        ".hermes/node",
        ".hermes/lsp",
        ".hermes/checkpoints",
        ".hermes/state-snapshots",
        ".hermes/trash",
    ]

    with tarfile.open(output_file, "w:gz") as tar:
        for source in source_dirs:
            tar.add(source, arcname=os.path.basename(source),
                    exclude=lambda name: any(ex in name for ex in excludes))
    return output_file


def upload_to_onedrive(file_path, access_token):
    """分片上传到 OneDrive"""
    session = requests.Session()
    session.trust_env = False  # 关键：不读代理
    session.headers.update({
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/octet-stream"
    })

    file_size = os.path.getsize(file_path)
    file_name = os.path.basename(file_path)

    # 1. 创建上传会话
    create_url = f"https://graph.microsoft.com/v1.0/me/drive/root:/{ONEDRIVE_BACKUP_PATH}/{file_name}:/createUploadSession"
    resp = session.post(create_url, json={"item": {"@microsoft.graph.conflictBehavior": "replace"}})
    upload_url = resp.json()["uploadUrl"]

    # 2. 分片上传
    with open(file_path, "rb") as f:
        offset = 0
        while offset < file_size:
            chunk = f.read(CHUNK_SIZE)
            end = offset + len(chunk) - 1
            headers = {
                "Content-Length": str(len(chunk)),
                "Content-Range": f"bytes {offset}-{end}/{file_size}"
            }

            for attempt in range(5):
                resp = session.put(upload_url, data=chunk, headers=headers)
                if resp.status_code in (200, 201, 202):
                    break
                print(f"分片 {offset}-{end} 重试 {attempt+1}/5")
                time.sleep(3 + attempt)
            else:
                raise Exception(f"分片 {offset}-{end} 上传失败")

            offset = end + 1
            print(f"已上传 {offset}/{file_size} bytes ({100*offset//file_size}%)")

    return True


# 主流程
tar_file = create_backup_tar(["/root/.hermes", "/root/scripts"], "/tmp/backup.tar.gz")
print(f"打包完成: {os.path.getsize(tar_file) / 1024 / 1024:.1f} MB")

upload_to_onedrive(tar_file, access_token="...")
print("✅ 上传成功")

import requests

def delete_blocks_one_by_one(doc_token, parent_id, headers, start, end):
    """从 end 往 start 倒序删除"""
    current_end = end
    while current_end > start:
        # 先获取当前最新的 document_revision_id
        rev_resp = requests.get(
            f"https://open.feishu.cn/open-apis/docx/v1/documents/{doc_token}",
            headers=headers
        )
        rev = rev_resp.json()["data"]["document"]["revision_id"]

        # 删除一个 block
        del_resp = requests.delete(
            f"https://open.feishu.cn/open-apis/docx/v1/documents/{doc_token}/blocks/{parent_id}/children/batch_delete",
            params={"document_revision_id": rev},
            json={"start_index": current_end - 1, "end_index": current_end},
            headers=headers
        )
        if del_resp.json().get("code") != 0:
            raise Exception(f"删除失败: {del_resp.json()}")
        current_end -= 1

def replace_content(doc_token, parent_id, new_content_blocks, headers):
    """用新内容替换文档内容"""
    # 1. 先删掉最后一个 block（保留索引 0 用于锚定）
    rev = get_revision(doc_token, headers)
    requests.delete(
        f"https://open.feishu.cn/open-apis/docx/v1/documents/{doc_token}/blocks/{parent_id}/children/batch_delete",
        params={"document_revision_id": rev},
        json={"start_index": 1, "end_index": 2},  # 假设文档原有内容在 1-2
        headers=headers
    )

    # 2. 批量插入新内容
    requests.post(
        f"https://open.feishu.cn/open-apis/docx/v1/documents/{doc_token}/blocks/{parent_id}/children",
        json={"children": new_content_blocks},
        headers=headers
    )

# 1. 引导用户授权
auth_url = (
    "https://open.feishu.cn/open-apis/authen/v2/index?"
    "app_id=YOUR_APP_ID&"
    "redirect_uri=YOUR_REDIRECT&"
    "scope=docx:document:write_only"
)
# 用户访问 auth_url 并授权后，会回调到 redirect_uri 并带上 code

# 2. 用 code 换 user_access_token
resp = requests.post(
    "https://open.feishu.cn/open-apis/authen/v2/oauth/token",
    json={
        "grant_type": "authorization_code",
        "code": code_from_callback,
        "client_id": "YOUR_APP_ID",
        "client_secret": "YOUR_APP_SECRET"
    }
)
user_access_token = resp.json()["access_token"]

import requests
import json

FEISHU_BASE = "https://open.feishu.cn/open-apis/docx/v1"

def clear_and_write_doc(doc_token, parent_id, tenant_token, new_blocks):
    """清空飞书文档指定区域并写入新内容"""
    headers = {
        "Authorization": f"Bearer {tenant_token}",
        "Content-Type": "application/json"
    }

    # 1. 获取文档当前总 block 数
    doc_resp = requests.get(
        f"{FEISHU_BASE}/documents/{doc_token}",
        headers=headers
    ).json()
    rev = doc_resp["data"]["document"]["revision_id"]
    block_count = len(doc_resp["data"]["document"]["blocks"])

    # 2. 从后往前逐个删除（保留索引 0 的占位 block）
    if block_count > 1:
        for i in range(block_count - 1, 0, -1):
            # 每次重新拿最新 revision_id
            rev = requests.get(
                f"{FEISHU_BASE}/documents/{doc_token}",
                headers=headers
            ).json()["data"]["document"]["revision_id"]

            del_resp = requests.delete(
                f"{FEISHU_BASE}/documents/{doc_token}/blocks/{parent_id}/children/batch_delete",
                params={"document_revision_id": rev},
                json={"start_index": i, "end_index": i + 1},
                headers=headers
            ).json()
            if del_resp.get("code") != 0:
                print(f"删除第 {i} 个 block 失败: {del_resp}")
                break

    # 3. 批量创建新内容
    create_resp = requests.post(
        f"{FEISHU_BASE}/documents/{doc_token}/blocks/{parent_id}/children",
        headers=headers,
        json={"children": new_blocks}
    ).json()
    return create_resp

# 用法
new_blocks = [
    {"block_type": 2, "text": {"elements": [{"text_run": {"content": "今日日报"}}]}},
    {"block_type": 2, "text": {"elements": [{"text_run": {"content": "AI 行业有 3 条重要新闻..."}}]}},
    # ... 更多 block
]

result = clear_and_write_doc(
    doc_token="你的文档ID",
    parent_id="父 block ID",
    tenant_token="应用的 tenant_access_token",
    new_blocks=new_blocks
)
print(result)

import time

for i in range(60):  # 最多轮询 5 分钟
    status = call_tool("mineru_status", {"task_id": task_id})
    if status["state"] == "completed":
        return status["result"]
    time.sleep(5)

import openai

client = openai.OpenAI(
    api_key="你的AccessSecret",
    base_url="https://developer.zhihu.com/v1",
    default_headers={"X-Request-Timestamp": str(int(time.time()))}
)

response = client.chat.completions.create(
    model="zhida-thinking-1p5",  # 深度思考模式
    messages=[{"role": "user", "content": "什么是 RAG？"}]
)

import requests
import time
import openai

ACCESS_SECRET = "你的AccessSecret"
HEADERS = {
    "Authorization": f"Bearer {ACCESS_SECRET}",
    "X-Request-Timestamp": str(int(time.time())),
    "Content-Type": "application/json"
}

# 1. 拉热榜
hot = requests.get(
    "https://developer.zhihu.com/api/v1/content/hot_list",
    headers=HEADERS,
    params={"Limit": 10}
).json()

# 2. 用直答 API 给每个热点生成一段解读
client = openai.OpenAI(
    api_key=ACCESS_SECRET,
    base_url="https://developer.zhihu.com/v1",
    default_headers=HEADERS
)

for item in hot["Data"]["Items"]:
    response = client.chat.completions.create(
        model="zhida-fast-1p5",
        messages=[{
            "role": "user",
            "content": f"请用 100 字解读这个知乎热榜话题：{item['Title']}"
        }],
        stream=False
    )
    print(f"🔥 {item['Title']}")
    print(f"   {response.choices[0].message.content}\n")
    time.sleep(1)  # 避免频率限制

import json
from http.server import BaseHTTPRequestHandler, HTTPServer
import urllib.request

# 自己设置一个"安全通行证" key，避免被他人盗用
LOCAL_ACCESS_KEY = "sk-你的自定义密钥"

# 元宝原始 API Key（160位）
API_KEY = "原始key填这里"
MODEL_ID = "openclaw_yuanbao_robot_model"
YUANBAO_URL = "https://bot.yuanbao.tencent.com/api/bot/chat/completions"

class ProxyHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        # 1. 验证调用方身份
        auth_header = self.headers.get('Authorization', '')
        if not auth_header or LOCAL_ACCESS_KEY not in auth_header:
            self.send_response(401)
            self.end_headers()
            self.wfile.write(b'{"error": "Unauthorized"}')
            return

        # 2. 路由：只接受标准 OpenAI 路径
        if self.path not in ["/v1/chat/completions", "/chat/completions"]:
            self.send_response(404)
            self.end_headers()
            return

        try:
            content_length = int(self.headers['Content-Length'])
            input_json = json.loads(self.rfile.read(content_length).decode('utf-8'))
            is_stream = input_json.get("stream", False)

            # 3. 转换为元宝格式
            yuanbao_payload = {
                "model": MODEL_ID,
                "messages": input_json.get("messages", []),
                "stream": False
            }

            req = urllib.request.Request(
                YUANBAO_URL,
                data=json.dumps(yuanbao_payload).encode('utf-8'),
                headers={
                    "Content-Type": "application/json",
                    "Authorization": f"Bearer {API_KEY}",
                    "X-Model-Id": MODEL_ID
                },
                method="POST"
            )

            with urllib.request.urlopen(req) as response:
                resp_json = json.loads(response.read().decode('utf-8'))

                # 4. 关键：强制转换 Token 为整数
                if "usage" in resp_json and resp_json["usage"]:
                    for k in ["prompt_tokens", "completion_tokens", "total_tokens"]:
                        if k in resp_json["usage"]:
                            resp_json["usage"][k] = int(resp_json["usage"][k])

                # 5. 根据 stream 参数决定返回
                if is_stream:
                    # 模拟 SSE 流式响应
                    self.send_response(200)
                    self.send_header("Content-Type", "text/event-stream")
                    self.end_headers()
                    content = resp_json["choices"][0]["message"]["content"]
                    chunk = {
                        "id": resp_json.get("id"),
                        "object": "chat.completion.chunk",
                        "model": "yuanbao",
                        "choices": [{"index": 0, "delta": {"content": content}, "finish_reason": "stop"}]
                    }
                    self.wfile.write(f"data: {json.dumps(chunk)}\n\n".encode())
                    self.wfile.write(b"data: [DONE]\n\n")
                else:
                    self.send_response(200)
                    self.send_header("Content-Type", "application/json")
                    self.end_headers()
                    self.wfile.write(json.dumps(resp_json).encode())
        except Exception as e:
            self.send_response(500)
            self.end_headers()
            self.wfile.write(str(e).encode())

if __name__ == "__main__":
    HTTPServer(("0.0.0.0", 16048), ProxyHandler).serve_forever()

if "usage" in resp_json and resp_json["usage"]:
    for k in ["prompt_tokens", "completion_tokens", "total_tokens"]:
        if k in resp_json["usage"]:
            resp_json["usage"][k] = int(resp_json["usage"][k])

# 客户端请求 stream=False 时：直接返回 JSON
# 客户端请求 stream=True 时：内部用 stream=False 调元宝，再自己模拟 SSE 输出
yuanbao_payload["stream"] = False  # 永远关闭后端的流式

if is_stream:
    # 一次性拿全量，再分块发送
    ...

# 思考块透传
chunk["choices"][0]["delta"]["reasoning_content"] = "..."

# 工具块透传
chunk["choices"][0]["delta"]["tool_calls"] = [...]