rednote-cli 0.1.0__py3-none-any.whl

rednote_cli/_runtime/services/scraper_service.py

@@ -0,0 +1,235 @@
+from typing import List, Optional, Union
+
+from rednote_cli._runtime.common.enums import Platform, XsecSource
+from rednote_cli._runtime.common.errors import PublishExecutionError, PublishNoteException
+from rednote_cli._runtime.core.account_manager import AccountLeaseManager, AccountManager
+from rednote_cli._runtime.core.browser.manager import browser_manager
+from rednote_cli._runtime.platforms.factory import PlatformFactory
+from rednote_cli._runtime.platforms.base import RiskControlException
+from rednote_cli._runtime.platforms.publishing.media import MediaPreprocessor
+from rednote_cli._runtime.platforms.publishing.models import PublishResult, PublishStage, PublishTarget
+from rednote_cli._runtime.platforms.publishing import normalize_publish_request
+
+
+def _normalize_xsec_source(xsec_source: Union[XsecSource, str, None]) -> XsecSource:
+    if isinstance(xsec_source, XsecSource):
+        return xsec_source
+    if isinstance(xsec_source, str) and xsec_source:
+        for source in XsecSource:
+            if source.value == xsec_source:
+                return source
+    return XsecSource.PC_FEED
+
+
+def _normalize_platform(platform: Union[Platform, str, None]) -> Platform:
+    if isinstance(platform, Platform):
+        return platform
+    if isinstance(platform, str) and platform:
+        for item in Platform:
+            if item.value == platform:
+                return item
+    return Platform.REDNOTE
+
+
+def _strip_sensitive_account_fields(accounts: List[dict]) -> List[dict]:
+    cleaned = []
+    for account in accounts:
+        item = dict(account)
+        item.pop("storage_state", None)
+        cleaned.append(item)
+    return cleaned
+
+
+def _build_publish_result_from_raw(raw_result) -> PublishResult:
+    if isinstance(raw_result, dict):
+        uploaded_count = int(raw_result.get("uploaded_count", 0) or 0)
+        status = str(raw_result.get("status", "")).strip().lower()
+        if status in {"uploaded", "submitted", "success", "verified"}:
+            if status == "uploaded":
+                stage = PublishStage.UPLOAD_DONE
+            elif status == "verified":
+                stage = PublishStage.VERIFIED
+            else:
+                stage = PublishStage.SUBMITTED
+            return PublishResult(
+                success=True,
+                stage=stage,
+                uploaded_count=uploaded_count,
+                publish_url=str(raw_result.get("publish_url") or ""),
+                publish_id=str(raw_result.get("publish_id") or ""),
+                message=str(raw_result.get("message") or ""),
+                data=raw_result,
+            )
+        return PublishResult(
+            success=False,
+            stage=PublishStage.FAILED,
+            uploaded_count=uploaded_count,
+            message=str(raw_result.get("message") or "发布失败"),
+            data=raw_result,
+        )
+
+    return PublishResult(
+        success=False,
+        stage=PublishStage.FAILED,
+        message=f"无法识别的发布返回值类型: {type(raw_result).__name__}",
+    )
+
+
+async def search_notes(
+        keyword: str,
+        size: int = 20,
+        sort_by: Optional[str] = None,
+        note_type: Optional[str] = None,
+        publish_time: Optional[str] = None,
+        search_scope: Optional[str] = None,
+        location: Optional[str] = None,
+        account_uid: Optional[str] = None,
+        platform: Union[Platform, str, None] = Platform.REDNOTE
+) -> List[dict]:
+    platform_enum = _normalize_platform(platform)
+    async with AccountLeaseManager.lease_account(platform_enum, account_uid) as account:
+        storage_state = account.get("storage_state")
+        async with browser_manager.get_page(storage_state, account_key=account.get("user_no")) as page:
+            extractor = PlatformFactory.get_extractor(platform_enum, page)
+            notes = await extractor.search_notes(
+                keyword=keyword,
+                size=size,
+                sort_by=sort_by,
+                note_type=note_type,
+                publish_time=publish_time,
+                search_scope=search_scope,
+                location=location,
+            )
+            return notes if isinstance(notes, list) else []
+
+
+async def search_users(
+        keyword: str,
+        size: int = 20,
+        account_uid: Optional[str] = None,
+        platform: Union[Platform, str, None] = Platform.REDNOTE
+) -> List[dict]:
+    platform_enum = _normalize_platform(platform)
+    async with AccountLeaseManager.lease_account(platform_enum, account_uid) as account:
+        storage_state = account.get("storage_state")
+        async with browser_manager.get_page(storage_state, account_key=account.get("user_no")) as page:
+            extractor = PlatformFactory.get_extractor(platform_enum, page)
+            users = await extractor.search_users(keyword, size)
+            return users if isinstance(users, list) else []
+
+
+async def get_user_info(
+        user_id: str,
+        xsec_token: Optional[str] = None,
+        xsec_source: Union[XsecSource, str, None] = XsecSource.PC_FEED,
+        account_uid: Optional[str] = None,
+        platform: Union[Platform, str, None] = Platform.REDNOTE
+) -> dict:
+    platform_enum = _normalize_platform(platform)
+    normalized_source = _normalize_xsec_source(xsec_source)
+    async with AccountLeaseManager.lease_account(platform_enum, account_uid) as account:
+        storage_state = account.get("storage_state")
+        async with browser_manager.get_page(storage_state, account_key=account.get("user_no")) as page:
+            extractor = PlatformFactory.get_extractor(platform_enum, page)
+            return await extractor.get_user_info(user_id, xsec_token, normalized_source)
+
+
+async def get_note_info(
+        note_id: str,
+        xsec_token: Optional[str] = None,
+        xsec_source: Union[XsecSource, str, None] = XsecSource.PC_FEED,
+        account_uid: Optional[str] = None,
+        comment_size: int = 10,
+        sub_comment_size: int = 5,
+        platform: Union[Platform, str, None] = Platform.REDNOTE,
+) -> dict:
+    platform_enum = _normalize_platform(platform)
+    normalized_source = _normalize_xsec_source(xsec_source)
+    async with AccountLeaseManager.lease_account(platform_enum, account_uid) as account:
+        storage_state = account.get("storage_state")
+        async with browser_manager.get_page(storage_state, account_key=account.get("user_no")) as page:
+            extractor = PlatformFactory.get_extractor(platform_enum, page)
+            return await extractor.get_note_info(
+                note_id=note_id,
+                xsec_token=xsec_token,
+                xsec_source=normalized_source,
+                comment_size=comment_size,
+                sub_comment_size=sub_comment_size,
+            )
+
+
+async def get_self_info(
+        account_uid: Optional[str] = None,
+        platform: Union[Platform, str, None] = Platform.REDNOTE,
+) -> dict:
+    platform_enum = _normalize_platform(platform)
+    async with AccountLeaseManager.lease_account(platform_enum, account_uid) as account:
+        storage_state = account.get("storage_state")
+        async with browser_manager.get_page(storage_state, account_key=account.get("user_no")) as page:
+            extractor = PlatformFactory.get_extractor(platform_enum, page)
+            return await extractor.get_self_info()
+
+
+async def publish_note(
+        target: str,
+        image_list: Optional[list] = None,
+        title: str = "",
+        content: str = "",
+        tags: Optional[list] = None,
+        schedule_at: Optional[str] = None,
+        account_uid: Optional[str] = None,
+        platform: Union[Platform, str, None] = Platform.REDNOTE,
+) -> dict:
+    platform_enum = _normalize_platform(platform)
+    request = normalize_publish_request(
+        target=target,
+        title=title,
+        content=content,
+        media_list=image_list,
+        tags=tags,
+        schedule_at=schedule_at,
+        account_uid=account_uid,
+    )
+    stage = PublishStage.INIT
+    try:
+        async with MediaPreprocessor() as preprocessor:
+            if request.target == PublishTarget.IMAGE:
+                prepared_media = await preprocessor.prepare_images(request.media_list)
+            elif request.target == PublishTarget.VIDEO:
+                prepared_media = await preprocessor.prepare_videos(request.media_list)
+            else:
+                prepared_media = list(request.media_list or [])
+            stage = PublishStage.MEDIA_READY
+
+            async with AccountLeaseManager.lease_account(platform_enum, request.account_uid) as account:
+                storage_state = account.get("storage_state")
+                account_key = account.get("user_no")
+                async with browser_manager.get_page(storage_state, account_key=account_key) as page:
+                    extractor = PlatformFactory.get_extractor(platform_enum, page)
+                    raw_result = await extractor.publish_note(
+                        target=request.target.value,
+                        image_list=prepared_media,
+                        title=request.title,
+                        content=request.content,
+                        tags=request.tags,
+                        schedule_at=request.schedule_at,
+                    )
+                    result = _build_publish_result_from_raw(raw_result)
+                    if result.stage == PublishStage.UPLOAD_DONE:
+                        result.data["pipeline_stage"] = PublishStage.UPLOAD_DONE.value
+                    return result.to_dict()
+    except RiskControlException:
+        raise
+    except PublishNoteException:
+        raise
+    except Exception as exc:
+        raise PublishExecutionError(f"发布编排执行失败(stage={stage.value}): {exc}") from exc
+
+
+async def list_accounts(
+        platform: str = Platform.REDNOTE.value,
+        only_active: bool = True
+) -> List[dict]:
+    accounts = AccountManager.list_accounts(only_active=only_active)
+    filtered = [acc for acc in accounts if acc.get("platform") == platform]
+    return _strip_sensitive_account_fields(filtered)

rednote_cli/adapters/__init__.py

@@ -0,0 +1 @@
+"""Adapters layer."""

rednote_cli/adapters/output/__init__.py

@@ -0,0 +1 @@
+"""Output adapters."""

rednote_cli/adapters/output/event_stream.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from rednote_cli.adapters.output.writer import write_error
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def emit_event(
+    *,
+    command: str,
+    event: str,
+    data: dict[str, Any] | None = None,
+    trace_id: str | None = None,
+) -> None:
+    payload = {
+        "type": "event",
+        "command": command,
+        "event": event,
+        "timestamp": _now_iso(),
+        "trace_id": trace_id,
+        "data": data or {},
+    }
+    write_error(json.dumps(payload, ensure_ascii=False, separators=(",", ":")))

rednote_cli/adapters/output/formatter_json.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def format_json(payload: Any, ensure_ascii: bool = False, indent: int = 2) -> str:
+    if isinstance(payload, BaseModel):
+        data = payload.model_dump(mode="json")
+    else:
+        data = payload
+    return json.dumps(data, ensure_ascii=ensure_ascii, indent=indent)
+
+
+def format_jsonl(payloads: list[Any], ensure_ascii: bool = False) -> str:
+    lines = []
+    for item in payloads:
+        if isinstance(item, BaseModel):
+            item = item.model_dump(mode="json")
+        lines.append(json.dumps(item, ensure_ascii=ensure_ascii))
+    return "\n".join(lines)

rednote_cli/adapters/output/formatter_table.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from io import StringIO
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+
+def _normalize_rows(data: Any) -> list[dict]:
+    if isinstance(data, list):
+        rows = []
+        for item in data:
+            if isinstance(item, dict):
+                rows.append(item)
+            else:
+                rows.append({"value": item})
+        return rows
+
+    if isinstance(data, dict):
+        return [data]
+
+    return [{"value": data}]
+
+
+def format_table(data: Any) -> str:
+    rows = _normalize_rows(data)
+    columns = sorted({key for row in rows for key in row.keys()})
+    table = Table(show_header=True, header_style="bold cyan")
+    for col in columns:
+        table.add_column(col, overflow="fold")
+
+    for row in rows:
+        table.add_row(*[str(row.get(col, "")) for col in columns])
+
+    buffer = StringIO()
+    console = Console(file=buffer, force_terminal=False, color_system=None)
+    console.print(table)
+    return buffer.getvalue().rstrip()

rednote_cli/adapters/output/writer.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def write_output(content: str, out_file: str | None = None) -> None:
+    print(content)
+    if out_file:
+        path = Path(out_file).expanduser().resolve()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content + "\n", encoding="utf-8")
+
+
+def write_error(content: str) -> None:
+    sys.stderr.write(content + "\n")
+    sys.stderr.flush()

rednote_cli/adapters/persistence/__init__.py

@@ -0,0 +1 @@
+"""Persistence adapters."""

rednote_cli/adapters/persistence/file_account_repo.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Any
+
+from rednote_cli._runtime.core.database.manager import DatabaseManager
+
+
+class FileAccountRepository:
+    @staticmethod
+    def _resolve_account(platform: str, account_uid: str) -> dict[str, Any] | None:
+        target = str(account_uid or "").strip()
+        if not target:
+            return None
+        accounts = DatabaseManager.get_all_accounts(only_active=False)
+        for item in accounts:
+            if item.get("platform") != platform:
+                continue
+            if str(item.get("user_no") or "").strip() == target:
+                return item
+        return None
+
+    @staticmethod
+    def _to_cli_account(item: dict[str, Any]) -> dict[str, Any]:
+        output = dict(item)
+        output.pop("storage_state", None)
+        output["account_uid"] = output.get("user_no")
+        return output
+
+    def list_accounts(self, platform: str = "Rednote", only_active: bool = True) -> list[dict[str, Any]]:
+        accounts = DatabaseManager.get_all_accounts(only_active=only_active)
+        filtered = [acc for acc in accounts if acc.get("platform") == platform]
+        return [self._to_cli_account(item) for item in filtered]
+
+    def delete(self, platform: str, account_uid: str) -> bool:
+        record = self._resolve_account(platform=platform, account_uid=account_uid)
+        if not record:
+            return False
+        DatabaseManager.delete_account(platform, record["user_no"])
+        return True
+
+    def activate(self, platform: str, account_uid: str) -> bool:
+        record = self._resolve_account(platform=platform, account_uid=account_uid)
+        if not record:
+            return False
+        return DatabaseManager.set_account_login_status(platform=platform, user_no=record["user_no"], is_logged_in=True)
+
+    def deactivate(self, platform: str, account_uid: str) -> bool:
+        record = self._resolve_account(platform=platform, account_uid=account_uid)
+        if not record:
+            return False
+        return DatabaseManager.set_account_login_status(platform=platform, user_no=record["user_no"], is_logged_in=False)

rednote_cli/adapters/platform/__init__.py

@@ -0,0 +1 @@
+"""Platform adapters."""

rednote_cli/adapters/platform/rednote/__init__.py

@@ -0,0 +1 @@
+"""Rednote platform adapters."""

rednote_cli/adapters/platform/rednote/extractor.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from rednote_cli._runtime.services import scraper_service
+
+
+class RednoteExtractorAdapter:
+    async def search_notes(
+        self,
+        keyword: str,
+        size: int,
+        sort_by: str | None = None,
+        note_type: str | None = None,
+        publish_time: str | None = None,
+        search_scope: str | None = None,
+        location: str | None = None,
+        account_uid: str | None = None,
+    ) -> list[dict]:
+        return await scraper_service.search_notes(
+            keyword=keyword,
+            size=size,
+            sort_by=sort_by,
+            note_type=note_type,
+            publish_time=publish_time,
+            search_scope=search_scope,
+            location=location,
+            account_uid=account_uid,
+        )
+
+    async def search_users(self, keyword: str, size: int, account_uid: str | None = None) -> list[dict]:
+        return await scraper_service.search_users(keyword=keyword, size=size, account_uid=account_uid)
+
+    async def get_user_info(
+        self,
+        user_id: str,
+        xsec_token: str | None = None,
+        xsec_source: str | None = "pc_feed",
+        account_uid: str | None = None,
+    ) -> dict:
+        return await scraper_service.get_user_info(
+            user_id=user_id,
+            xsec_token=xsec_token,
+            xsec_source=xsec_source,
+            account_uid=account_uid,
+        )
+
+    async def get_note_info(
+        self,
+        note_id: str,
+        xsec_token: str | None = None,
+        xsec_source: str | None = "pc_feed",
+        comment_size: int = 10,
+        sub_comment_size: int = 5,
+        account_uid: str | None = None,
+    ) -> dict:
+        return await scraper_service.get_note_info(
+            note_id=note_id,
+            xsec_token=xsec_token,
+            xsec_source=xsec_source,
+            comment_size=comment_size,
+            sub_comment_size=sub_comment_size,
+            account_uid=account_uid,
+        )
+
+    async def get_self_info(self, account_uid: str | None = None) -> dict:
+        return await scraper_service.get_self_info(account_uid=account_uid)

rednote_cli/adapters/platform/rednote/publisher.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from rednote_cli._runtime.services import scraper_service
+
+
+class RednotePublisherAdapter:
+    async def publish_note(
+        self,
+        *,
+        target: str,
+        image_list: list[str],
+        title: str = "",
+        content: str = "",
+        tags: list[str] | None = None,
+        schedule_at: str | None = None,
+        account_uid: str | None = None,
+    ) -> dict:
+        return await scraper_service.publish_note(
+            target=target,
+            image_list=image_list,
+            title=title,
+            content=content,
+            tags=tags,
+            schedule_at=schedule_at,
+            account_uid=account_uid,
+        )