rednote-cli 0.1.0__py3-none-any.whl

rednote_cli/_runtime/platforms/publishing/__init__.py

@@ -0,0 +1,12 @@
+from rednote_cli._runtime.platforms.publishing.media import MediaPreprocessor
+from rednote_cli._runtime.platforms.publishing.models import PublishRequest, PublishResult, PublishStage, PublishTarget
+from rednote_cli._runtime.platforms.publishing.validator import normalize_publish_request
+
+__all__ = [
+    "MediaPreprocessor",
+    "PublishRequest",
+    "PublishResult",
+    "PublishStage",
+    "PublishTarget",
+    "normalize_publish_request",
+]

rednote_cli/_runtime/platforms/publishing/media.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import tempfile
+import urllib.parse
+from pathlib import Path
+from urllib.request import Request, urlopen
+
+from rednote_cli._runtime.common.errors import InvalidPublishParameterError, PublishMediaPreparationError
+
+
+def _is_url(path: str) -> bool:
+    try:
+        parsed = urllib.parse.urlparse(path)
+        return bool(parsed.scheme and parsed.netloc)
+    except Exception:
+        return False
+
+
+def _guess_image_extension(file_head: bytes, content_type: str = "") -> str:
+    ct = (content_type or "").lower()
+    if file_head.startswith(b"\xFF\xD8\xFF"):
+        return ".jpg"
+    if file_head.startswith(b"\x89PNG\r\n\x1a\n"):
+        return ".png"
+    if file_head.startswith((b"GIF87a", b"GIF89a")):
+        return ".gif"
+    if len(file_head) >= 12 and file_head[:4] == b"RIFF" and file_head[8:12] == b"WEBP":
+        return ".webp"
+    if file_head.startswith(b"BM"):
+        return ".bmp"
+    if file_head.startswith((b"II*\x00", b"MM\x00*")):
+        return ".tiff"
+
+    if "png" in ct:
+        return ".png"
+    if "jpeg" in ct or "jpg" in ct:
+        return ".jpg"
+    if "webp" in ct:
+        return ".webp"
+    if "gif" in ct:
+        return ".gif"
+    if "bmp" in ct:
+        return ".bmp"
+    if "tiff" in ct:
+        return ".tiff"
+    return ""
+
+
+def _guess_video_extension(file_head: bytes, content_type: str = "", source_suffix: str = "") -> str:
+    suffix = (source_suffix or "").strip().lower()
+    if suffix in {".mp4", ".mov"}:
+        return suffix
+
+    ct = (content_type or "").lower()
+    if "video/mp4" in ct:
+        return ".mp4"
+    if "video/quicktime" in ct:
+        return ".mov"
+
+    # MP4/MOV both belong to ISO BMFF and commonly contain `ftyp` in the first bytes.
+    if len(file_head) >= 12 and file_head[4:8] == b"ftyp":
+        major_brand = file_head[8:12]
+        if major_brand == b"qt  ":
+            return ".mov"
+        return ".mp4"
+
+    return ""
+
+
+def _supported_extensions_text(extensions: set[str]) -> str:
+    return ", ".join(ext.lstrip(".") for ext in sorted(extensions))
+
+
+class MediaPreprocessor:
+    """Prepare and validate media assets before publish flow."""
+
+    def __init__(
+        self,
+        allowed_image_extensions: set[str] | None = None,
+        allowed_video_extensions: set[str] | None = None,
+        temp_prefix: str = "publish_upload_",
+    ):
+        self.allowed_image_extensions = allowed_image_extensions or {".png", ".jpg", ".jpeg", ".webp"}
+        self.allowed_video_extensions = allowed_video_extensions or {".mp4", ".mov"}
+        self.temp_prefix = temp_prefix
+        self.temp_dir: str | None = None
+
+    async def __aenter__(self) -> "MediaPreprocessor":
+        self.temp_dir = tempfile.mkdtemp(prefix=self.temp_prefix)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.cleanup()
+
+    async def cleanup(self) -> None:
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            await asyncio.to_thread(shutil.rmtree, self.temp_dir, True)
+            self.temp_dir = None
+
+    async def prepare_images(self, media_list: list[str]) -> list[str]:
+        normalized = self._normalize_media_list(media_list, field_name="media_list")
+        final_paths: list[str] = []
+
+        for index, item in enumerate(normalized):
+            if _is_url(item):
+                final_paths.append(await self._download_image(item, index))
+            else:
+                final_paths.append(await self._validate_local_image(item))
+        return final_paths
+
+    async def prepare_videos(self, media_list: list[str]) -> list[str]:
+        normalized = self._normalize_media_list(media_list, field_name="media_list")
+        final_paths: list[str] = []
+
+        for index, item in enumerate(normalized):
+            if _is_url(item):
+                final_paths.append(await self._download_video(item, index))
+            else:
+                final_paths.append(await self._validate_local_video(item))
+        return final_paths
+
+    @staticmethod
+    def _normalize_media_list(media_list: list, field_name: str) -> list[str]:
+        if media_list is None:
+            raise InvalidPublishParameterError(f"`{field_name}` 不能为空")
+        if not isinstance(media_list, (list, tuple)):
+            raise InvalidPublishParameterError(f"`{field_name}` 必须是 list 或 tuple")
+        if len(media_list) == 0:
+            raise InvalidPublishParameterError(f"`{field_name}` 至少包含 1 个文件")
+
+        normalized = []
+        for index, item in enumerate(media_list):
+            text = "" if item is None else str(item).strip()
+            if not text:
+                raise InvalidPublishParameterError(f"`{field_name}` 第 {index + 1} 项不能为空")
+            normalized.append(text)
+        return normalized
+
+    async def _validate_local_image(self, image_path: str) -> str:
+        local_path = Path(image_path)
+        if not local_path.exists():
+            raise InvalidPublishParameterError(f"本地图片不存在: {image_path}")
+        if not local_path.is_file():
+            raise InvalidPublishParameterError(f"路径不是一个有效文件: {image_path}")
+
+        suffix = local_path.suffix.lower()
+        if suffix not in self.allowed_image_extensions:
+            supported = _supported_extensions_text(self.allowed_image_extensions)
+            raise InvalidPublishParameterError(f"不支持的文件格式: {image_path} (仅支持 {supported})")
+
+        try:
+            head = await asyncio.to_thread(self._read_file_head, local_path, 64)
+        except Exception as e:
+            raise PublishMediaPreparationError(f"读取本地图片失败: {image_path}。原因: {e}") from e
+
+        detected = _guess_image_extension(head)
+        if detected and detected not in self.allowed_image_extensions:
+            supported = _supported_extensions_text(self.allowed_image_extensions)
+            raise InvalidPublishParameterError(f"本地图片格式不支持: {image_path} (仅支持 {supported})")
+
+        return str(local_path.absolute())
+
+    async def _validate_local_video(self, video_path: str) -> str:
+        local_path = Path(video_path)
+        if not local_path.exists():
+            raise InvalidPublishParameterError(f"本地视频不存在: {video_path}")
+        if not local_path.is_file():
+            raise InvalidPublishParameterError(f"路径不是一个有效文件: {video_path}")
+        if local_path.stat().st_size <= 0:
+            raise InvalidPublishParameterError(f"本地视频文件为空: {video_path}")
+
+        suffix = local_path.suffix.lower()
+        if suffix not in self.allowed_video_extensions:
+            supported = _supported_extensions_text(self.allowed_video_extensions)
+            raise InvalidPublishParameterError(f"不支持的视频格式: {video_path} (仅支持 {supported})")
+        return str(local_path.absolute())
+
+    async def _download_image(self, image_url: str, index: int) -> str:
+        if not self.temp_dir:
+            self.temp_dir = tempfile.mkdtemp(prefix=self.temp_prefix)
+        return await asyncio.to_thread(self._download_image_sync, image_url, index)
+
+    async def _download_video(self, video_url: str, index: int) -> str:
+        if not self.temp_dir:
+            self.temp_dir = tempfile.mkdtemp(prefix=self.temp_prefix)
+        return await asyncio.to_thread(self._download_video_sync, video_url, index)
+
+    def _download_image_sync(self, image_url: str, index: int) -> str:
+        req = Request(image_url, method="GET")
+        req.add_header(
+            "User-Agent",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+        )
+        parsed = urllib.parse.urlparse(image_url)
+        req.add_header("Referer", f"{parsed.scheme}://{parsed.netloc}/")
+
+        try:
+            with urlopen(req, timeout=20) as resp:
+                status = getattr(resp, "status", 200)
+                if status != 200:
+                    raise PublishMediaPreparationError(f"图片下载失败，HTTP 状态码: {status}, url: {image_url}")
+                body = resp.read()
+                content_type = (resp.headers.get("Content-Type") or "").lower()
+        except Exception as e:
+            raise PublishMediaPreparationError(f"图片下载失败: {image_url}。原因: {e}") from e
+
+        ext = _guess_image_extension(body[:64], content_type=content_type)
+        if not ext:
+            raise InvalidPublishParameterError(f"无法识别图片格式: {image_url}")
+        if ext not in self.allowed_image_extensions:
+            supported = _supported_extensions_text(self.allowed_image_extensions)
+            raise InvalidPublishParameterError(f"不支持的图片格式: {image_url} (仅支持 {supported})")
+
+        target_path = Path(self.temp_dir) / f"download_{index}{ext}"
+        try:
+            with open(target_path, "wb") as output:
+                output.write(body)
+        except Exception as e:
+            raise PublishMediaPreparationError(f"保存图片失败: {image_url}。原因: {e}") from e
+
+        return str(target_path.absolute())
+
+    def _download_video_sync(self, video_url: str, index: int) -> str:
+        req = Request(video_url, method="GET")
+        req.add_header(
+            "User-Agent",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+        )
+        parsed = urllib.parse.urlparse(video_url)
+        req.add_header("Referer", f"{parsed.scheme}://{parsed.netloc}/")
+
+        source_suffix = Path(urllib.parse.urlparse(video_url).path).suffix.lower()
+        supported = _supported_extensions_text(self.allowed_video_extensions)
+
+        try:
+            with urlopen(req, timeout=60) as resp:
+                status = getattr(resp, "status", 200)
+                if status != 200:
+                    raise PublishMediaPreparationError(f"视频下载失败，HTTP 状态码: {status}, url: {video_url}")
+                content_type = (resp.headers.get("Content-Type") or "").lower()
+
+                first_chunk = resp.read(64 * 1024)
+                if not first_chunk:
+                    raise InvalidPublishParameterError(f"视频下载为空: {video_url}")
+
+                ext = _guess_video_extension(first_chunk[:64], content_type=content_type, source_suffix=source_suffix)
+                if not ext:
+                    raise InvalidPublishParameterError(f"无法识别视频格式: {video_url}")
+                if ext not in self.allowed_video_extensions:
+                    raise InvalidPublishParameterError(f"不支持的视频格式: {video_url} (仅支持 {supported})")
+
+                target_path = Path(self.temp_dir) / f"download_{index}{ext}"
+                with open(target_path, "wb") as output:
+                    output.write(first_chunk)
+                    while True:
+                        chunk = resp.read(1024 * 1024)
+                        if not chunk:
+                            break
+                        output.write(chunk)
+        except InvalidPublishParameterError:
+            raise
+        except Exception as e:
+            raise PublishMediaPreparationError(f"视频下载失败: {video_url}。原因: {e}") from e
+
+        return str(target_path.absolute())
+
+    @staticmethod
+    def _read_file_head(path: Path, size: int) -> bytes:
+        with open(path, "rb") as f:
+            return f.read(size)

rednote_cli/_runtime/platforms/publishing/models.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Optional
+
+
+class PublishTarget(str, Enum):
+    IMAGE = "image"
+    VIDEO = "video"
+    ARTICLE = "article"
+
+
+class PublishStage(str, Enum):
+    INIT = "init"
+    MEDIA_READY = "media_ready"
+    PAGE_READY = "page_ready"
+    UPLOAD_DONE = "upload_done"
+    FORM_FILLED = "form_filled"
+    SUBMITTED = "submitted"
+    VERIFIED = "verified"
+    FAILED = "failed"
+
+
+@dataclass
+class PublishRequest:
+    target: PublishTarget
+    title: str
+    content: str
+    media_list: list[str]
+    tags: list[str] = field(default_factory=list)
+    schedule_at: Optional[datetime] = None
+    account_uid: Optional[str] = None
+
+
+@dataclass
+class PublishResult:
+    success: bool
+    stage: PublishStage
+    uploaded_count: int = 0
+    publish_url: str = ""
+    publish_id: str = ""
+    risk_flags: list[str] = field(default_factory=list)
+    message: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = {
+            "success": self.success,
+            "stage": self.stage.value,
+            "uploaded_count": self.uploaded_count,
+            "publish_url": self.publish_url,
+            "publish_id": self.publish_id,
+            "risk_flags": self.risk_flags,
+            "message": self.message,
+        }
+        payload.update(self.data)
+        return payload

rednote_cli/_runtime/platforms/publishing/validator.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Iterable, Optional, Union
+
+from rednote_cli._runtime.common.errors import InvalidPublishParameterError, UnsupportedPublishTargetError
+from rednote_cli._runtime.platforms.publishing.models import PublishRequest, PublishTarget
+
+
+def calc_title_length(title: str) -> int:
+    byte_len = 0
+    for ch in title:
+        byte_len += 2 if ord(ch) > 127 else 1
+    return (byte_len + 1) // 2
+
+
+def parse_rfc3339(value: str) -> datetime:
+    text = value.strip()
+    if text.endswith("Z"):
+        text = text[:-1] + "+00:00"
+    dt = datetime.fromisoformat(text)
+    if dt.tzinfo is None:
+        raise InvalidPublishParameterError("`schedule_at` 必须包含时区，例如 +08:00")
+    return dt
+
+
+def _normalize_target(target: Union[str, PublishTarget]) -> PublishTarget:
+    if isinstance(target, PublishTarget):
+        return target
+    if not target:
+        raise InvalidPublishParameterError("`target` 不能为空")
+    text = str(target).strip().lower()
+    for item in PublishTarget:
+        if item.value == text:
+            return item
+    raise UnsupportedPublishTargetError(f"不支持的 target: {target}，当前支持: image, video, article")
+
+
+def _normalize_text_list(items: Optional[Iterable], field_name: str) -> list[str]:
+    if items is None:
+        return []
+    if not isinstance(items, (list, tuple)):
+        raise InvalidPublishParameterError(f"`{field_name}` 必须是 list 或 tuple")
+
+    normalized: list[str] = []
+    for index, item in enumerate(items):
+        text = "" if item is None else str(item).strip()
+        if not text:
+            raise InvalidPublishParameterError(f"`{field_name}` 第 {index + 1} 项不能为空")
+        normalized.append(text)
+    return normalized
+
+
+def _normalize_media_list(media_list: Optional[Iterable], required: bool) -> list[str]:
+    if media_list is None and not required:
+        return []
+    normalized = _normalize_text_list(media_list, "media_list")
+    if required and not normalized:
+        raise InvalidPublishParameterError("`media_list` 至少包含 1 个素材")
+    return normalized
+
+
+def _normalize_schedule(schedule_at: Optional[Union[str, datetime]]) -> Optional[datetime]:
+    if schedule_at is None:
+        return None
+    if isinstance(schedule_at, datetime):
+        dt = schedule_at
+    else:
+        dt = parse_rfc3339(str(schedule_at))
+
+    if dt.tzinfo is None:
+        raise InvalidPublishParameterError("`schedule_at` 必须包含时区，例如 +08:00")
+
+    now = datetime.now(dt.tzinfo)
+    min_time = now + timedelta(hours=1)
+    max_time = now + timedelta(days=14)
+    if dt < min_time:
+        raise InvalidPublishParameterError(
+            f"定时发布时间至少在 1 小时后，当前: {dt.strftime('%Y-%m-%d %H:%M')}, 最早: {min_time.strftime('%Y-%m-%d %H:%M')}"
+        )
+    if dt > max_time:
+        raise InvalidPublishParameterError(
+            f"定时发布时间不能超过 14 天，当前: {dt.strftime('%Y-%m-%d %H:%M')}, 最晚: {max_time.strftime('%Y-%m-%d %H:%M')}"
+        )
+    return dt
+
+
+def normalize_publish_request(
+        *,
+        target: Union[str, PublishTarget],
+        title: str = "",
+        content: str = "",
+        media_list: Optional[Iterable] = None,
+        tags: Optional[Iterable] = None,
+        schedule_at: Optional[Union[str, datetime]] = None,
+        account_uid: Optional[str] = None,
+) -> PublishRequest:
+    normalized_target = _normalize_target(target)
+    media_required = normalized_target in {PublishTarget.IMAGE, PublishTarget.VIDEO}
+    normalized_media = _normalize_media_list(media_list, required=media_required)
+    normalized_tags = _normalize_text_list(tags, "tags")
+
+    if normalized_target == PublishTarget.VIDEO and len(normalized_media) != 1:
+        raise InvalidPublishParameterError("`target=video` 时 `media_list` 必须且仅包含 1 个视频素材")
+
+    title_text = (title or "").strip()
+    content_text = (content or "").strip()
+    if title_text and calc_title_length(title_text) > 20:
+        raise InvalidPublishParameterError("标题长度超过限制（最多 20）")
+
+    if len(normalized_tags) > 10:
+        normalized_tags = normalized_tags[:10]
+
+    normalized_schedule = _normalize_schedule(schedule_at)
+
+    return PublishRequest(
+        target=normalized_target,
+        title=title_text,
+        content=content_text,
+        media_list=normalized_media,
+        tags=normalized_tags,
+        schedule_at=normalized_schedule,
+        account_uid=(account_uid or "").strip() or None,
+    )

rednote_cli/_runtime/services/__init__.py

@@ -0,0 +1 @@
+"""Service package for CLI runtime."""