Skip to content

利用 AI 大模型和自动化工作流,根据主题或关键词一键生成高清短视频。Generate HD short videos from a topic or keyword with an automated AI workflow.

fix(upload-post): verify publish results (#1444)

Rudy Mizrahi Celekli8ea1cf734c31
diff --git a/app/services/task.py b/app/services/task.py
index 8dd43342..93127a60 100644
--- a/app/services/task.py
+++ b/app/services/task.py
@@ -1217,18 +1217,44 @@ def _run_cross_post(
)
for video_path in video_paths:
+ pending_result_index = None
+
+ def record_background_request(request_id: str) -> None:
+ nonlocal pending_result_index
+ # Persist the remote handle before polling. If this process
+ # exits mid-upload, recovery can expose the ID to the user.
+ pending_result_index = len(results)
+ results.append(
+ {
+ "video_index": pending_result_index + 1,
+ "request_id": request_id,
+ "status": "processing",
+ }
+ )
+ if _patch_cross_post_state(
+ task_id, cross_post_results=list(results)
+ ) is not True:
+ logger.warning(
+ "could not persist background upload request ID: "
+ f"task_id={task_id}, request_id={request_id}"
+ )
+
result = upload_post.cross_post_video(
video_path=video_path,
title=post_title,
platforms=list(platforms),
youtube_extra=youtube_extra,
+ on_background_start=record_background_request,
)
if not isinstance(result, dict):
result = {
"success": False,
"error": "Upload-Post returned an invalid response",
}
- results.append(result)
+ if pending_result_index is None:
+ results.append(result)
+ else:
+ results[pending_result_index] = result
failures = [result for result in results if not result.get("success")]
if failures:
diff --git a/app/services/upload_post.py b/app/services/upload_post.py
index 3910e572..2f99a734 100644
--- a/app/services/upload_post.py
+++ b/app/services/upload_post.py
@@ -4,16 +4,113 @@ Upload-Post API integration for cross-posting videos to TikTok, Instagram and Yo
Docs: https://docs.upload-post.com
"""
import os
-from typing import Optional
+import time
+from typing import Callable, Optional
import requests
from loguru import logger
from app.config import config
+_UPLOAD_STATUS_POLL_INTERVAL_SECONDS = 10
+_UPLOAD_STATUS_TIMEOUT_SECONDS = 3600
+_MAX_CONSECUTIVE_STATUS_ERRORS = 3
+
+
class UploadPostService:
API_BASE = "https://api.upload-post.com"
+ @staticmethod
+ def _with_platform_outcome(result: dict) -> dict:
+ """A successful API request can still contain failed platform publishes."""
+ platform_results = result.get("results")
+ if isinstance(platform_results, dict):
+ entries = platform_results.items()
+ elif isinstance(platform_results, list):
+ entries = (
+ (
+ entry.get("platform", "unknown")
+ if isinstance(entry, dict)
+ else "unknown",
+ entry,
+ )
+ for entry in platform_results
+ )
+ else:
+ if "results" in result:
+ return {
+ **result,
+ "success": False,
+ "error": "Upload-Post returned invalid platform results",
+ }
+ return result
+
+ failures = [
+ str(platform)
+ for platform, entry in entries
+ if not isinstance(entry, dict)
+ or entry.get("success") is not True
+ or entry.get("skipped") is True
+ ]
+ if not platform_results:
+ failures.append("no platform results")
+ if failures:
+ return {
+ **result,
+ "success": False,
+ "error": "Upload-Post failed or skipped platforms: "
+ + ", ".join(failures),
+ }
+ return result
+
+ def _wait_for_upload_completion(self, request_id: str) -> dict:
+ """Resolve Upload-Post's automatic sync-to-background fallback."""
+ consecutive_errors = 0
+ deadline = time.monotonic() + _UPLOAD_STATUS_TIMEOUT_SECONDS
+ while True:
+ status_result = self.check_status(request_id)
+ status = status_result.get("status")
+ if status == "completed":
+ if not isinstance(status_result.get("results"), (dict, list)):
+ return {
+ **status_result,
+ "request_id": request_id,
+ "success": False,
+ "error": "Upload-Post completed without platform results",
+ }
+ return self._with_platform_outcome(
+ {**status_result, "request_id": request_id, "success": True}
+ )
+ if status == "failed":
+ return {
+ **status_result,
+ "request_id": request_id,
+ "success": False,
+ "error": status_result.get("message")
+ or "Upload-Post background upload failed",
+ }
+ if status in {"pending", "queued", "processing", "in_progress"}:
+ consecutive_errors = 0
+ else:
+ consecutive_errors += 1
+ if consecutive_errors >= _MAX_CONSECUTIVE_STATUS_ERRORS:
+ return {
+ "success": False,
+ "request_id": request_id,
+ "error": "Upload-Post status could not be confirmed; "
+ f"check request_id {request_id}",
+ }
+ remaining = deadline - time.monotonic()
+ if remaining <= 0:
+ break
+ time.sleep(min(_UPLOAD_STATUS_POLL_INTERVAL_SECONDS, remaining))
+ return {
+ "success": False,
+ "request_id": request_id,
+ "error": "Upload-Post status did not complete within 1 hour; "
+ f"check request_id {request_id}",
+ }
+
@property
def api_key(self) -> str:
return config.app.get("upload_post_api_key", "")
@@ -55,6 +152,7 @@ class UploadPostService:
platforms: Optional[list] = None,
privacy_level: str = "PUBLIC_TO_EVERYONE",
youtube_extra: Optional[dict] = None,
+ on_background_start: Callable[[str], None] | None = None,
) -> dict:
if not self.is_configured():
logger.warning("Upload-Post is not configured. Skipping cross-post.")
@@ -120,22 +218,64 @@ class UploadPostService:
)
response.raise_for_status()
- result = response.json()
- if not isinstance(result, dict) or not isinstance(
- result.get("success"), bool
- ):
- logger.error("Upload-Post returned an invalid response to upload")
+ try:
+ result = response.json()
+ except ValueError:
+ logger.error("Upload-Post returned invalid JSON to upload")
return {
"success": False,
- "error": "Upload-Post returned an invalid response",
+ "error": "Upload-Post returned invalid JSON",
}
- if result.get('success'):
- logger.info(f"✅ Video cross-posted successfully! Request ID: {result.get('request_id')}")
+ # Release the source file before waiting for a remote background
+ # upload, which can take much longer than the initial POST.
+ if not isinstance(result, dict) or not isinstance(
+ result.get("success"), bool
+ ):
+ logger.error("Upload-Post returned an invalid response to upload")
+ return {
+ "success": False,
+ "error": "Upload-Post returned an invalid response",
+ }
+
+ if result["success"]:
+ is_background = "results" not in result
+ if is_background:
+ request_id = result.get("request_id")
+ if not isinstance(request_id, str) or not request_id.strip():
+ return {
+ "success": False,
+ "error": "Upload-Post started a background upload "
+ "without a request_id",
+ }
+ logger.info(
+ "Upload-Post background upload accepted: "
+ f"request_id={request_id.strip()}"
+ )
+ if on_background_start is not None:
+ try:
+ on_background_start(request_id.strip())
+ except Exception as exc:
+ # The remote upload has already started. A local
+ # status-write failure must not resubmit the video.
+ logger.warning(
+ "failed to record background upload request ID: "
+ f"{exc}"
+ )
+ result = self._wait_for_upload_completion(request_id.strip())
else:
- logger.warning(f"Cross-post failed: {result.get('message', 'Unknown error')}")
+ result = self._with_platform_outcome(result)
- return result
+ if result.get("success"):
+ logger.info(
+ f"Video cross-posted successfully! Request ID: {result.get('request_id')}"
+ )
+ else:
+ logger.warning(
+ f"Cross-post failed: {result.get('error') or result.get('message') or 'Unknown error'}"
+ )
+
+ return result
except requests.exceptions.RequestException as e:
logger.error(f"Failed to cross-post video: {str(e)}")
@@ -164,7 +304,14 @@ class UploadPostService:
)
response.raise_for_status()
- result = response.json()
+ try:
+ result = response.json()
+ except ValueError:
+ logger.error("Upload-Post returned invalid JSON to status query")
+ return {
+ "success": False,
+ "error": "Upload-Post returned invalid status JSON",
+ }
if not isinstance(result, dict):
logger.error("Upload-Post returned an invalid response to status query")
return {
@@ -187,5 +334,12 @@ def cross_post_video(
title: str,
platforms: Optional[list] = None,
youtube_extra: Optional[dict] = None,
+ on_background_start: Callable[[str], None] | None = None,
) -> dict:
- return upload_post_service.upload_video(video_path, title, platforms, youtube_extra=youtube_extra)
+ return upload_post_service.upload_video(
+ video_path,
+ title,
+ platforms,
+ youtube_extra=youtube_extra,
+ on_background_start=on_background_start,
+ )
diff --git a/test/services/test_task.py b/test/services/test_task.py
index 46e266e1..bdee385c 100644
--- a/test/services/test_task.py
+++ b/test/services/test_task.py
@@ -1657,6 +1657,92 @@ class TestTaskService(unittest.TestCase):
self.assertEqual(task["cross_post_state"], tm.const.CROSS_POST_STATE_FAILED)
self.assertIn("metadata provider unavailable", task["cross_post_error"])
+ def test_background_upload_request_id_is_saved_while_polling(self):
+ """An interrupted worker must leave the remote upload ID in task state."""
+ state = MemoryState()
+ state.update_task(
+ "background-upload",
+ state=tm.const.TASK_STATE_COMPLETE,
+ progress=100,
+ videos=["final.mp4"],
+ cross_post_state=tm.const.CROSS_POST_STATE_PENDING,
+ )
+ observed = {}
+
+ def upload_with_background_start(**kwargs):
+ kwargs["on_background_start"]("request-42")
+ observed.update(state.get_task("background-upload"))
+ return {"success": True, "request_id": "request-42"}
+
+ with (
+ patch.object(tm.sm, "state", state),
+ patch.object(tm.llm, "generate_social_metadata", return_value={}),
+ patch.object(
+ tm.upload_post,
+ "cross_post_video",
+ side_effect=upload_with_background_start,
+ ),
+ ):
+ tm._run_cross_post(
+ "background-upload",
+ ("final.mp4",),
+ "Coffee",
+ "Coffee script",
+ "en",
+ ("tiktok",),
+ "public",
+ )
+
+ self.assertEqual(
+ observed["cross_post_state"], tm.const.CROSS_POST_STATE_PROCESSING
+ )
+ self.assertEqual(
+ observed["cross_post_results"][0]["request_id"], "request-42"
+ )
+ finished = state.get_task("background-upload")
+ self.assertEqual(finished["cross_post_state"], tm.const.CROSS_POST_STATE_COMPLETE)
+ self.assertEqual(finished["cross_post_results"], [{"success": True, "request_id": "request-42"}])
+
+ def test_background_upload_request_id_survives_worker_error(self):
+ """A polling exception must not erase the only remote recovery handle."""
+ state = MemoryState()
+ state.update_task(
+ "background-upload-error",
+ state=tm.const.TASK_STATE_COMPLETE,
+ progress=100,
+ videos=["final.mp4"],
+ cross_post_state=tm.const.CROSS_POST_STATE_PENDING,
+ )
+
+ def interrupted_upload(**kwargs):
+ kwargs["on_background_start"]("request-lost")
+ raise RuntimeError("worker stopped during status polling")
+
+ with (
+ patch.object(tm.sm, "state", state),
+ patch.object(tm.llm, "generate_social_metadata", return_value={}),
+ patch.object(
+ tm.upload_post,
+ "cross_post_video",
+ side_effect=interrupted_upload,
+ ),
+ ):
+ tm._run_cross_post(
+ "background-upload-error",
+ ("final.mp4",),
+ "Coffee",
+ "Coffee script",
+ "en",
+ ("tiktok",),
+ "public",
+ )
+
+ failed = state.get_task("background-upload-error")
+ self.assertEqual(failed["cross_post_state"], tm.const.CROSS_POST_STATE_FAILED)
+ self.assertEqual(
+ failed["cross_post_results"][0]["request_id"], "request-lost"
+ )
+
def test_start_returns_cross_post_scheduling_failure(self):
"""同步调度失败必须同时体现在任务状态和 start() 返回快照中。"""
params = VideoParams(video_subject="Coffee")
diff --git a/test/services/test_upload_post.py b/test/services/test_upload_post.py
index 911fa1c7..17421b60 100644
--- a/test/services/test_upload_post.py
+++ b/test/services/test_upload_post.py
@@ -22,7 +22,11 @@ _CONFIG_BASE = {
def _mock_response(success=True):
r = MagicMock()
- r.json.return_value = {"success": success, "request_id": "abc123"}
+ r.json.return_value = {
+ "success": success,
+ "request_id": "abc123",
+ "results": {"tiktok": {"success": success}},
+ }
r.raise_for_status = MagicMock()
return r
@@ -143,6 +147,177 @@ class TestUploadPostService(unittest.TestCase):
self.assertIs(result["success"], False)
self.assertIn("invalid response", result["error"])
+ @patch("app.services.upload_post.config.app", _CONFIG_BASE)
+ @patch("app.services.upload_post.os.path.exists", return_value=True)
+ @patch("builtins.open", mock_open(read_data=b"fake"))
+ @patch("app.services.upload_post.requests.post")
+ def test_sync_upload_reports_failed_platform(self, mock_post, _exists):
+ """Top-level success means accepted even when one platform failed."""
+ response = _mock_response()
+ response.json.return_value = {
+ "success": True,
+ "results": {
+ "instagram": {"success": True},
+ "linkedin": {"success": False, "error": "account expired"},
+ },
+ }
+ mock_post.return_value = response
+
+ result = UploadPostService().upload_video(
+ "/fake/v.mp4", "Title", platforms=["instagram", "linkedin"]
+ )
+
+ self.assertIs(result["success"], False)
+ self.assertIn("linkedin", result["error"])
+ self.assertIn("results", result)
+
+ @patch("app.services.upload_post.config.app", _CONFIG_BASE)
+ @patch("app.services.upload_post.os.path.exists", return_value=True)
+ @patch("builtins.open", mock_open(read_data=b"fake"))
+ @patch("app.services.upload_post.requests.post")
+ def test_upload_without_results_uses_request_id_to_confirm_status(
+ self, mock_post, _exists
+ ):
+ """A returned request ID is still an in-flight upload without results."""
+ response = _mock_response()
+ response.json.return_value = {"success": True, "request_id": "req-only"}
+ mock_post.return_value = response
+
+ with patch.object(
+ UploadPostService,
+ "check_status",
+ return_value={
+ "status": "completed",
+ "results": [{"platform": "tiktok", "success": True}],
+ },
+ ) as check_status:
+ result = UploadPostService().upload_video(
+ "/fake/v.mp4", "Title", platforms=["tiktok"]
+ )
+
+ self.assertIs(result["success"], True)
+ check_status.assert_called_once_with("req-only")
+
+ @patch("app.services.upload_post.config.app", _CONFIG_BASE)
+ @patch("app.services.upload_post.os.path.exists", return_value=True)
+ @patch("builtins.open", mock_open(read_data=b"fake"))
+ @patch("app.services.upload_post.requests.post")
+ def test_upload_with_malformed_platform_results_fails(self, mock_post, _exists):
+ response = _mock_response()
+ response.json.return_value = {"success": True, "results": "unavailable"}
+ mock_post.return_value = response
+
+ result = UploadPostService().upload_video(
+ "/fake/v.mp4", "Title", platforms=["tiktok"]
+ )
+
+ self.assertIs(result["success"], False)
+ self.assertIn("invalid platform results", result["error"])
+
+ @patch("app.services.upload_post.config.app", _CONFIG_BASE)
+ @patch("app.services.upload_post.os.path.exists", return_value=True)
+ @patch("builtins.open", mock_open(read_data=b"fake"))
+ @patch("app.services.upload_post.requests.post")
+ def test_background_upload_waits_for_platform_results(self, mock_post, _exists):
+ """A 200 background acceptance must not become a completed cross-post."""
+ response = _mock_response()
+ response.json.return_value = {
+ "success": True,
+ "message": "Upload initiated successfully in background.",
+ "request_id": "req-123",
+ "total_platforms": 2,
+ }
+ mock_post.return_value = response
+
+ with (
+ patch.object(
+ UploadPostService,
+ "check_status",
+ side_effect=[
+ {"request_id": "req-123", "status": "processing"},
+ {
+ "request_id": "req-123",
+ "status": "completed",
+ "results": [
+ {"platform": "instagram", "success": True},
+ {"platform": "linkedin", "success": False},
+ ],
+ },
+ ],
+ ) as check_status,
+ patch("app.services.upload_post.time", create=True) as clock,
+ ):
+ clock.monotonic.return_value = 0
+ result = UploadPostService().upload_video(
+ "/fake/v.mp4", "Title", platforms=["instagram", "linkedin"]
+ )
+
+ self.assertIs(result["success"], False)
+ self.assertIn("linkedin", result["error"])
+ self.assertEqual(result["request_id"], "req-123")
+ self.assertEqual(check_status.call_count, 2)
+ clock.sleep.assert_called_once()
+
+ @patch("app.services.upload_post.config.app", _CONFIG_BASE)
+ @patch("app.services.upload_post.os.path.exists", return_value=True)
+ @patch("builtins.open", mock_open(read_data=b"fake"))
+ @patch("app.services.upload_post.requests.post")
+ def test_background_upload_reports_completed_platforms(self, mock_post, _exists):
+ response = _mock_response()
+ response.json.return_value = {
+ "success": True,
+ "message": "Upload initiated successfully in background.",
+ "request_id": "req-complete",
+ "total_platforms": 1,
+ }
+ mock_post.return_value = response
+ completed = {
+ "status": "completed",
+ "results": [{"platform": "tiktok", "success": True}],
+ }
+ with patch.object(
+ UploadPostService, "check_status", return_value=completed
+ ) as check_status:
+ result = UploadPostService().upload_video(
+ "/fake/v.mp4", "Title", platforms=["tiktok"]
+ )
+
+ self.assertIs(result["success"], True)
+ self.assertEqual(result["request_id"], "req-complete")
+ check_status.assert_called_once_with("req-complete")
+
+ @patch("app.services.upload_post.config.app", _CONFIG_BASE)
+ @patch("app.services.upload_post.os.path.exists", return_value=True)
+ @patch("builtins.open", mock_open(read_data=b"fake"))
+ @patch("app.services.upload_post.requests.post")
+ def test_background_upload_timeout_keeps_request_id(self, mock_post, _exists):
+ response = _mock_response()
+ response.json.return_value = {
+ "success": True,
+ "message": "Upload initiated successfully in background.",
+ "request_id": "req-slow",
+ }
+ mock_post.return_value = response
+ with (
+ patch.object(
+ UploadPostService,
+ "check_status",
+ return_value={"status": "processing"},
+ ) as check_status,
+ patch("app.services.upload_post._UPLOAD_STATUS_TIMEOUT_SECONDS", 0),
+ patch("app.services.upload_post.time") as clock,
+ ):
+ clock.monotonic.return_value = 0
+ result = UploadPostService().upload_video(
+ "/fake/v.mp4", "Title", platforms=["tiktok"]
+ )
+
+ self.assertIs(result["success"], False)
+ self.assertEqual(result["request_id"], "req-slow")
+ self.assertIn("did not complete", result["error"])
+ check_status.assert_called_once()
+ clock.sleep.assert_not_called()
+
class TestUploadPostYouTubePayload(unittest.TestCase):
@patch("app.services.upload_post.config.app", _CONFIG_BASE)
diff --git a/test/services/test_youtube_audience.py b/test/services/test_youtube_audience.py
index 27b06412..93407b10 100644
--- a/test/services/test_youtube_audience.py
+++ b/test/services/test_youtube_audience.py
@@ -43,7 +43,10 @@ def test_audience_payload_and_snapshot_override(
video = tmp_path / "video.mp4"
video.write_bytes(b"test-media")
with patch("app.services.upload_post.requests.post") as post:
- post.return_value.json.return_value = {"success": True}
+ post.return_value.json.return_value = {
+ "success": True,
+ "results": {"youtube": {"success": True}},
+ }
result = UploadPostService().upload_video(
str(video), "test", youtube_extra=extra
)
@@ -74,7 +77,13 @@ def test_other_platforms_ignore_youtube_audience(tmp_path, upload_config):
video = tmp_path / "video.mp4"
video.touch()
with patch("app.services.upload_post.requests.post") as post:
- post.return_value.json.return_value = {"success": True}
+ post.return_value.json.return_value = {
+ "success": True,
+ "results": {
+ "tiktok": {"success": True},
+ "instagram": {"success": True},
+ },
+ }
result = UploadPostService().upload_video(
str(video),
"test",
@@ -148,7 +157,7 @@ def test_real_http_multipart_audience(tmp_path, upload_config, selected):
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.end_headers()
- self.wfile.write(b'{"success": true, "request_id": "local-only"}')
+ self.wfile.write(b'{"success": true, "results": {"youtube": {"success": true}}}')
def log_message(self, *_args):
# 本机接收器不打印请求头,测试输出无需包含认证信息。