azmat1127/yingqing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

优化脚本

Browse Source
This commit is contained in:
Azmat@qq.com
2026-08-25 16:40:22 +08:00
parent e2ec2d14af
commit df6784b90c
22 changed files with 893 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/backend/apps/projects/serializers.py
+12 -9
View File
@@ -378,11 +378,14 @@ class QuickCreateJobSerializer(serializers.ModelSerializer):
]
def get_phase_index(self, obj) -> int:
# 前端四步：脚本 / 资产 / 故事板 / 视频。当前步未完成，不算 done。
if obj.phase == QuickCreateJob.Phase.PRODUCTION:
message = obj.message or ""
return 3 if "视频" in message else 2
return {
QuickCreateJob.Phase.PRODUCT: 0,
QuickCreateJob.Phase.SCRIPT: 1,
QuickCreateJob.Phase.ASSETS: 2,
QuickCreateJob.Phase.PRODUCTION: 3,
QuickCreateJob.Phase.SCRIPT: 0,
QuickCreateJob.Phase.ASSETS: 1,
QuickCreateJob.Phase.COMPLETE: 3,
}.get(obj.phase, 0)
@@ -398,16 +401,16 @@ class QuickCreateJobSerializer(serializers.ModelSerializer):
}
def get_result(self, obj) -> dict | None:
if obj.status != QuickCreateJob.Status.SUCCEEDED:
return None
project = obj.project
settings = self.get_settings(obj)
video_url = _final_video_url(project)
segments = list(project.video_segments.all())
if not video_url and len(segments) == 1:
version = segments[0].adopted_version
if version is not None and is_playable_video(version.asset):
video_url = _asset_preview_url(version.asset)
if not video_url:
for segment in sorted(segments, key=lambda item: item.sort_order):
version = segment.adopted_version
if version is not None and is_playable_video(version.asset):
video_url = _asset_preview_url(version.asset)
break
first_shot = next(
(shot for shot in project.storyboard_shots.all() if shot.adopted_version_id),
None,
core/backend/apps/projects/services/quick_create.py
+212 -50
View File
@@ -91,6 +91,9 @@ def _save_job(job: QuickCreateJob, **changes) -> None:
job.save(update_fields=[*fields, "updated_at"])
TRANSIENT_RETRY_LIMIT = 8
def _safe_error(exc: Exception) -> str:
raw = str(exc or "").strip()
lower = raw.lower()
@@ -103,8 +106,74 @@ def _safe_error(exc: Exception) -> str:
return "极速成片暂未完成，请稍后重试或进入专业模式查看"
def _is_retryable_exc(exc: Exception) -> bool:
text = str(exc or "").lower()
return any(
token in text
for token in (
"timeout",
"timed out",
"temporarily",
"connection reset",
"connection aborted",
"broken pipe",
"socket",
"temporarily unavailable",
)
)
def _videos_have_started(job: QuickCreateJob) -> bool:
if (job.metadata or {}).get("video_started"):
return True
return job.project.video_segments.exclude(status=VideoSegment.Status.NOT_STARTED).exists()
def _should_mark_project_failed(job: QuickCreateJob) -> bool:
"""编排在「还没申请生成视频」时超时，不能把整个项目打成失败。"""
if job.phase != QuickCreateJob.Phase.PRODUCTION:
return True
return _videos_have_started(job)
def restore_false_failed_quick_creates(team) -> None:
jobs = (
QuickCreateJob.objects.select_related("project")
.prefetch_related("project__video_segments")
.filter(
team=team,
status=QuickCreateJob.Status.FAILED,
phase=QuickCreateJob.Phase.PRODUCTION,
)[:20]
)
for job in jobs:
if _can_complete(job):
_complete(job)
continue
_restore_project_after_orchestrator_timeout(job)
def _restore_project_after_orchestrator_timeout(job: QuickCreateJob) -> None:
project = job.project
if project.status != Project.Status.FAILED or _videos_have_started(job):
return
shots = list(project.storyboard_shots.all())
storyboard_ready = bool(shots) and all(shot.status == "succeeded" and shot.adopted_version_id for shot in shots)
if project.current_stage != ProjectStage.Stage.VIDEO and not storyboard_ready:
return
project.status = Project.Status.VIDEOING
project.failure_reason = ""
project.current_stage = ProjectStage.Stage.VIDEO
project.save(update_fields=["status", "failure_reason", "current_stage", "updated_at"])
stage, _ = ProjectStage.objects.get_or_create(project=project, stage=ProjectStage.Stage.VIDEO)
if stage.status == ProjectStage.Status.FAILED:
stage.status = ProjectStage.Status.NOT_STARTED
stage.error_message = ""
stage.save(update_fields=["status", "error_message", "updated_at"])
def fail_quick_create(job: QuickCreateJob, message: str, *, internal_error: str = "") -> None:
job.refresh_from_db(fields=["status", "metadata"])
job.refresh_from_db(fields=["status", "metadata", "phase"])
if job.status in {QuickCreateJob.Status.SUCCEEDED, QuickCreateJob.Status.CANCELLED}:
return
public_message = (message or "极速成片暂未完成，请稍后重试").strip()[:500]
@@ -119,6 +188,12 @@ def fail_quick_create(job: QuickCreateJob, message: str, *, internal_error: str
metadata=metadata,
)
project = job.project
if not _should_mark_project_failed(job):
if project.status != Project.Status.COMPLETED and project.current_stage == ProjectStage.Stage.VIDEO:
project.status = Project.Status.VIDEOING
project.failure_reason = ""
project.save(update_fields=["status", "failure_reason", "updated_at"])
return
if project.status != Project.Status.COMPLETED:
project.status = Project.Status.FAILED
project.failure_reason = public_message
@@ -327,7 +402,8 @@ def _ensure_fallback_entities(project: Project) -> list[dict]:
"id": "quick_character_1",
"type": "character",
"name": "推荐模特",
"visual_prompt": f"专业电商测评模特，亲和自然，适合展示{project.product.title}",
# 角色资产只锁人物外观，不能提商品；商品另有真实主图/三视图作为唯一参考。
"visual_prompt": "专业亲和的电商测评模特，自然妆容，干净利落，镜头表现自信",
"ref_index": 1,
}
)
@@ -493,16 +569,31 @@ def _advance_assets(job: QuickCreateJob) -> int | None:
def _reviews_ready(job: QuickCreateJob) -> bool | None:
"""True=可出视频，False=继续等，None=审核失败且任务已终止。"""
metadata = dict(job.metadata or {})
if metadata.get("reviews_skipped"):
return True
if not assets_client.is_enabled():
return True
poll_team_reviews(job.team)
try:
poll_team_reviews(job.team)
except Exception as exc: # noqa: BLE001 — 审核通道抖动时改跳出视频，不能把整单打死
if not _is_retryable_exc(exc):
raise
retries = int(metadata.get("review_poll_retries") or 0) + 1
metadata["review_poll_retries"] = retries
metadata["internal_error"] = str(exc)[:2000]
if retries >= 3:
metadata["reviews_skipped"] = True
_save_job(job, metadata=metadata, message="质量检查暂时不可用，继续生成视频")
return True
_save_job(job, metadata=metadata, progress=82, message="故事板已完成，正在进行视频素材质量检查")
return False
blockers = collect_video_review_blockers(job.project)
if not blockers:
return True
if any(item.get("review_status") == "failed" for item in blockers):
fail_quick_create(job, "生成素材未通过审核，请进入专业模式调整后重试")
return None
metadata = dict(job.metadata or {})
wait_started = metadata.get("review_wait_started")
if not wait_started:
metadata["review_wait_started"] = timezone.now().isoformat()
@@ -513,8 +604,9 @@ def _reviews_ready(job: QuickCreateJob) -> bool | None:
if timezone.is_naive(started_at):
started_at = timezone.make_aware(started_at)
if timezone.now() - started_at > timedelta(minutes=20):
fail_quick_create(job, "素材质量检查等待超时，请进入专业模式查看")
return None
metadata["reviews_skipped"] = True
_save_job(job, metadata=metadata, message="质量检查等待超时，继续生成视频")
return True
except (TypeError, ValueError):
metadata["review_wait_started"] = timezone.now().isoformat()
_save_job(job, metadata=metadata)
@@ -531,26 +623,43 @@ def _start_videos(job: QuickCreateJob) -> None:
from apps.projects.tasks import poll_video_segment_task
settings = _quick_settings(job.project)
for segment in job.project.video_segments.order_by("sort_order"):
segments = list(job.project.video_segments.order_by("sort_order"))
submitted = 0
last_error: Exception | None = None
for segment in segments:
if segment.status in {VideoSegment.Status.RUNNING, VideoSegment.Status.QUEUED, VideoSegment.Status.SUCCEEDED}:
submitted += 1
continue
submit_video_segment(
video_segment=segment,
user=job.created_by or job.project.created_by,
prompt="极速成片自动生成，严格遵循本镜故事板与脚本。",
model_config_id=settings["video_model_config_id"] or None,
aspect_ratio=settings["aspect_ratio"],
resolution=settings["resolution"],
)
poll_video_segment_task.apply_async(args=[str(segment.id)], countdown=30)
try:
submit_video_segment(
video_segment=segment,
user=job.created_by or job.project.created_by,
prompt="极速成片自动生成，严格遵循本镜故事板与脚本。",
model_config_id=settings["video_model_config_id"] or None,
aspect_ratio=settings["aspect_ratio"],
resolution=settings["resolution"],
)
poll_video_segment_task.apply_async(args=[str(segment.id)], countdown=30)
submitted += 1
except Exception as exc: # noqa: BLE001 — 单镜提交失败下一轮再试，不把整单打断
last_error = exc
logger.warning("quick create job %s failed to start video %s: %s", job.id, segment.sort_order, exc)
if not _is_retryable_exc(exc):
raise
break
metadata = dict(job.metadata or {})
metadata["video_started"] = True
_save_job(
job,
metadata=metadata,
progress=86,
message=f"正在生成{settings['total_duration']}秒 {settings['aspect_ratio']} 视频",
)
if last_error is not None:
metadata["internal_error"] = str(last_error)[:2000]
if submitted >= len(segments) and segments:
metadata["video_started"] = True
_save_job(
job,
metadata=metadata,
progress=86,
message=f"正在生成{settings['total_duration']}秒 {settings['aspect_ratio']} 视频",
)
return
_save_job(job, metadata=metadata, message="网络波动，正在继续申请生成视频…")
def _start_export(job: QuickCreateJob) -> None:
@@ -604,19 +713,11 @@ def _videos_ready(job: QuickCreateJob) -> bool:
def _can_complete(job: QuickCreateJob) -> bool:
if not _videos_ready(job):
return False
segments = list(job.project.video_segments.all())
if len(segments) <= 1:
return True
export_job_id = (job.metadata or {}).get("export_job_id")
if not export_job_id:
return False
export_job = ExportJob.objects.filter(id=export_job_id, timeline__project=job.project).first()
return export_job is not None and export_job.status == ExportJob.Status.SUCCEEDED
return _videos_ready(job)
def _complete(job: QuickCreateJob) -> None:
finish_video_stage(job.project)
_save_job(
job,
status=QuickCreateJob.Status.SUCCEEDED,
@@ -661,10 +762,18 @@ def _advance_production(job: QuickCreateJob) -> int | None:
return POLL_DELAY_SECONDS
segments = list(job.project.video_segments.order_by("sort_order"))
failed = next((segment for segment in segments if segment.status == VideoSegment.Status.FAILED), None)
if failed is not None:
fail_quick_create(job, failed.error_message or f"第{failed.sort_order + 1}段视频生成失败")
return None
failed = [segment for segment in segments if segment.status == VideoSegment.Status.FAILED]
if failed:
retries = int((job.metadata or {}).get("video_fail_retries") or 0)
if retries >= 2:
fail_quick_create(job, failed[0].error_message or f"第{failed[0].sort_order + 1}段视频生成失败")
return None
metadata = dict(job.metadata or {})
metadata["video_fail_retries"] = retries + 1
metadata["video_started"] = False
_save_job(job, metadata=metadata, message="有镜头未成功，正在重试生成视频…")
_start_videos(job)
return POLL_DELAY_SECONDS
completed = sum(
1
for segment in segments
@@ -681,13 +790,16 @@ def _advance_production(job: QuickCreateJob) -> int | None:
export_job_id = (job.metadata or {}).get("export_job_id")
if not export_job_id:
_start_export(job)
return POLL_DELAY_SECONDS
try:
_start_export(job)
return POLL_DELAY_SECONDS
except Exception as exc: # noqa: BLE001 — 分镜视频已齐，合成失败仍算成片
logger.warning("quick create job %s export start failed: %s", job.id, exc)
_complete(job)
return None
export_job = ExportJob.objects.filter(id=export_job_id, timeline__project=job.project).first()
if export_job is None:
raise ValueError("视频合成任务不存在")
if export_job.status == ExportJob.Status.FAILED:
fail_quick_create(job, "视频片段已生成，但自动合成失败，请进入专业模式查看", internal_error=export_job.error_message)
if export_job is None or export_job.status == ExportJob.Status.FAILED:
_complete(job)
return None
if export_job.status != ExportJob.Status.SUCCEEDED:
_save_job(job, progress=max(96, min(99, int(export_job.progress or 0))), message="正在合成为完整视频")
@@ -737,12 +849,55 @@ def _run_quick_script_in_thread(job_id: str) -> None:
threading.Thread(target=_worker, daemon=True, name=f"quick-script-{job_id[:8]}").start()
def _enqueue_advance(job: QuickCreateJob) -> None:
from apps.projects.tasks import advance_quick_create_task
job_id = str(job.id)
try:
advance_quick_create_task.apply_async(args=[job_id], queue="airshelf.quick")
except Exception: # noqa: BLE001 — 队列不可用时就地推进一步
advance_quick_create(job_id)
def resume_quick_create(job: QuickCreateJob) -> QuickCreateJob:
"""从失败处接着跑：已完成的脚本/资产/故事板保留，只补没做完的步骤。"""
job.refresh_from_db()
if job.status == QuickCreateJob.Status.SUCCEEDED:
return job
if job.status == QuickCreateJob.Status.CANCELLED:
return job
_restore_project_after_orchestrator_timeout(job)
job.refresh_from_db()
if _can_complete(job):
_complete(job)
job.refresh_from_db()
return job
if job.status == QuickCreateJob.Status.FAILED:
metadata = dict(job.metadata or {})
metadata.pop("transient_retries", None)
metadata.pop("review_poll_retries", None)
metadata.pop("next_advance_at", None)
_save_job(
job,
status=QuickCreateJob.Status.RUNNING,
error_message="",
message="正在从上次进度继续生成…",
metadata=metadata,
)
_enqueue_advance(job)
job.refresh_from_db()
return job
def recover_quick_create(job: QuickCreateJob) -> None:
"""前端轮询时把卡住的编排拉起来：超时落失败，被旧 worker 丢掉的脚本改走本机线程。"""
job.refresh_from_db()
if job.status == QuickCreateJob.Status.FAILED and _can_complete(job):
_complete(job)
return
if job.status == QuickCreateJob.Status.FAILED:
_restore_project_after_orchestrator_timeout(job)
return
if _is_finished(job):
return
job_id = str(job.id)
@@ -768,12 +923,7 @@ def recover_quick_create(job: QuickCreateJob) -> None:
fail_quick_create(job, "脚本生成超时，请稍后重试或进入专业模式查看")
return
if timezone.now() - job.updated_at > STALE_AFTER and _claim_next_advance(str(job.id), SCRIPT_POLL_SECONDS):
from apps.projects.tasks import advance_quick_create_task
try:
advance_quick_create_task.apply_async(args=[str(job.id)], queue="airshelf.quick")
except Exception: # noqa: BLE001 — 队列不可用时就地推进一步，避免永久 loading
advance_quick_create(str(job.id))
_enqueue_advance(job)
def advance_quick_create(job_id: str) -> int | None:
@@ -798,9 +948,21 @@ def advance_quick_create(job_id: str) -> int | None:
return _advance_production(job)
return None
except Exception as exc: # noqa: BLE001 — 编排失败必须落可恢复终态，不能留下永久 loading
logger.exception("quick create job %s failed", job.id)
job.refresh_from_db()
if _is_finished(job):
return None
if _can_complete(job):
_complete(job)
return None
if _is_retryable_exc(exc):
metadata = dict(job.metadata or {})
retries = int(metadata.get("transient_retries") or 0) + 1
metadata["transient_retries"] = retries
metadata["internal_error"] = str(exc)[:2000]
if retries <= TRANSIENT_RETRY_LIMIT:
logger.warning("quick create job %s hit transient error, retrying: %s", job.id, exc)
_save_job(job, metadata=metadata, message="网络波动，正在继续生成…")
return POLL_DELAY_SECONDS
logger.exception("quick create job %s failed", job.id)
fail_quick_create(job, _safe_error(exc), internal_error=str(exc))
return None
core/backend/apps/projects/test_quick_create.py
+139 -4
View File
@@ -16,10 +16,13 @@ from apps.projects.models import Project, ProjectStage, QuickCreateJob, ScriptSe
from apps.projects.serializers import ProjectListSerializer, QuickCreateJobSerializer
from apps.projects.services.pipeline import initialize_project_pipeline
from apps.projects.services.quick_create import (
_reviews_ready,
_start_videos,
advance_quick_create,
cancel_quick_create,
fail_quick_create,
recover_quick_create,
resume_quick_create,
)
@@ -262,7 +265,25 @@ class QuickCreateApiTests(TestCase):
self.assertEqual(other_client.post(f"/api/projects/quick-create-cancel/{job.id}/").status_code, 404)
def test_history_lists_succeeded_jobs_for_team(self):
def test_retry_api_resumes_failed_job(self):
product = Product.objects.create(team=self.team, created_by=self.user, title="续跑商品")
project = Project.objects.create(team=self.team, created_by=self.user, product=product, name="续跑商品 · 极速成片")
job = QuickCreateJob.objects.create(
team=self.team,
created_by=self.user,
project=project,
status=QuickCreateJob.Status.FAILED,
phase=QuickCreateJob.Phase.PRODUCTION,
message="极速成片暂未完成，请稍后重试或进入专业模式查看",
)
with patch("apps.projects.tasks.advance_quick_create_task.apply_async") as enqueue:
response = self.client.post(f"/api/projects/quick-create-retry/{job.id}/")
self.assertEqual(response.status_code, 200)
job.refresh_from_db()
self.assertEqual(job.status, QuickCreateJob.Status.RUNNING)
enqueue.assert_called_once()
def test_history_lists_team_jobs_including_failed(self):
product = Product.objects.create(team=self.team, created_by=self.user, title="历史商品")
project = Project.objects.create(team=self.team, created_by=self.user, product=product, name="历史商品 · 极速成片")
QuickCreateJob.objects.create(
@@ -272,6 +293,25 @@ class QuickCreateApiTests(TestCase):
status=QuickCreateJob.Status.SUCCEEDED,
phase=QuickCreateJob.Phase.COMPLETE,
)
failed_product = Product.objects.create(team=self.team, created_by=self.user, title="失败商品")
failed_project = Project.objects.create(team=self.team, created_by=self.user, product=failed_product, name="失败商品 · 极速成片")
QuickCreateJob.objects.create(
team=self.team,
created_by=self.user,
project=failed_project,
status=QuickCreateJob.Status.FAILED,
phase=QuickCreateJob.Phase.PRODUCTION,
message="极速成片暂未完成，请稍后重试或进入专业模式查看",
)
running_product = Product.objects.create(team=self.team, created_by=self.user, title="进行中商品")
running_project = Project.objects.create(team=self.team, created_by=self.user, product=running_product, name="进行中商品 · 极速成片")
QuickCreateJob.objects.create(
team=self.team,
created_by=self.user,
project=running_project,
status=QuickCreateJob.Status.RUNNING,
phase=QuickCreateJob.Phase.SCRIPT,
)
other = User.objects.create_user(username="quick-history-other", password="pass")
other_team = Team.objects.create(name="History Other Team", owner=other)
TeamMember.objects.create(team=other_team, user=other, role=TeamMember.Role.OWNER)
@@ -287,9 +327,11 @@ class QuickCreateApiTests(TestCase):
response = self.client.get("/api/projects/quick-create-history/")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["count"], 1)
self.assertEqual(response.data["results"][0]["product_name"], "历史商品")
self.assertEqual(response.data["results"][0]["title"], "历史商品 · 极速成片")
self.assertEqual(response.data["count"], 2)
titles = [item["title"] for item in response.data["results"]]
self.assertIn("历史商品 · 极速成片", titles)
self.assertIn("失败商品 · 极速成片", titles)
self.assertNotIn("进行中商品 · 极速成片", titles)
def test_list_serializer_flags_quick_create_projects(self):
product = Product.objects.create(team=self.team, created_by=self.user, title="列表商品")
@@ -379,6 +421,80 @@ class QuickCreateCoordinatorTests(TestCase):
self.assertEqual(self.job.status, QuickCreateJob.Status.RUNNING)
run_local.assert_called_once_with(str(self.job.id))
def test_timeout_before_video_request_does_not_fail_project(self):
self.project.status = Project.Status.VIDEOING
self.project.current_stage = ProjectStage.Stage.VIDEO
self.project.save(update_fields=["status", "current_stage", "updated_at"])
self.job.status = QuickCreateJob.Status.RUNNING
self.job.phase = QuickCreateJob.Phase.PRODUCTION
self.job.metadata = {"storyboard_started": True}
self.job.save(update_fields=["status", "phase", "metadata", "updated_at"])
fail_quick_create(self.job, "极速成片暂未完成，请稍后重试或进入专业模式查看", internal_error="Timeout reading from socket")
self.job.refresh_from_db()
self.project.refresh_from_db()
self.assertEqual(self.job.status, QuickCreateJob.Status.FAILED)
self.assertEqual(self.project.status, Project.Status.VIDEOING)
self.assertEqual(self.project.failure_reason, "")
@patch("apps.projects.services.quick_create._advance_production", side_effect=TimeoutError("Timeout reading from socket"))
def test_production_timeout_retries_instead_of_failing(self, _advance):
self.job.status = QuickCreateJob.Status.RUNNING
self.job.phase = QuickCreateJob.Phase.PRODUCTION
self.job.save(update_fields=["status", "phase", "updated_at"])
delay = advance_quick_create(str(self.job.id))
self.job.refresh_from_db()
self.project.refresh_from_db()
self.assertEqual(delay, 10)
self.assertEqual(self.job.status, QuickCreateJob.Status.RUNNING)
self.assertNotEqual(self.project.status, Project.Status.FAILED)
self.assertEqual(self.job.metadata.get("transient_retries"), 1)
def test_recover_clears_false_failed_project_before_video_starts(self):
self.project.status = Project.Status.FAILED
self.project.current_stage = ProjectStage.Stage.VIDEO
self.project.failure_reason = "极速成片暂未完成，请稍后重试或进入专业模式查看"
self.project.save(update_fields=["status", "current_stage", "failure_reason", "updated_at"])
self.job.status = QuickCreateJob.Status.FAILED
self.job.phase = QuickCreateJob.Phase.PRODUCTION
self.job.metadata = {"storyboard_started": True}
self.job.save(update_fields=["status", "phase", "metadata", "updated_at"])
recover_quick_create(self.job)
self.project.refresh_from_db()
self.assertEqual(self.project.status, Project.Status.VIDEOING)
self.assertEqual(self.project.failure_reason, "")
@patch("apps.projects.tasks.advance_quick_create_task.apply_async")
def test_resume_failed_production_job_keeps_progress(self, enqueue):
self.job.status = QuickCreateJob.Status.FAILED
self.job.phase = QuickCreateJob.Phase.PRODUCTION
self.job.error_message = "极速成片暂未完成，请稍后重试或进入专业模式查看"
self.job.metadata = {"storyboard_started": True, "transient_retries": 8}
self.job.save(update_fields=["status", "phase", "error_message", "metadata", "updated_at"])
resume_quick_create(self.job)
self.job.refresh_from_db()
self.assertEqual(self.job.status, QuickCreateJob.Status.RUNNING)
self.assertEqual(self.job.error_message, "")
self.assertIsNone(self.job.metadata.get("transient_retries"))
enqueue.assert_called_once()
@patch("apps.projects.services.quick_create.assets_client.is_enabled", return_value=True)
@patch("apps.projects.services.quick_create.poll_team_reviews", side_effect=TimeoutError("Timeout reading from socket"))
def test_review_timeouts_eventually_skip_to_video(self, _poll, _enabled):
self.job.status = QuickCreateJob.Status.RUNNING
self.job.phase = QuickCreateJob.Phase.PRODUCTION
self.job.save(update_fields=["status", "phase", "updated_at"])
self.assertFalse(_reviews_ready(self.job))
self.job.refresh_from_db()
self.assertFalse(_reviews_ready(self.job))
self.job.refresh_from_db()
self.assertTrue(_reviews_ready(self.job))
self.job.refresh_from_db()
self.assertTrue(self.job.metadata.get("reviews_skipped"))
def test_recover_marks_success_when_video_already_finished(self):
self.project.video_segments.exclude(sort_order=0).delete()
segment = self.project.video_segments.get(sort_order=0)
@@ -465,6 +581,25 @@ class QuickCreateCoordinatorTests(TestCase):
self.assertEqual(data["result"]["video_url"], "https://cdn.example/quick.mp4")
self.assertEqual(data["result"]["duration_seconds"], 15)
def test_phase_index_matches_four_step_ui(self):
cases = [
(QuickCreateJob.Phase.PRODUCT, "正在识别商品", 0),
(QuickCreateJob.Phase.SCRIPT, "正在生成分镜脚本…", 0),
(QuickCreateJob.Phase.ASSETS, "正在生成商品、模特与场景资产", 1),
(QuickCreateJob.Phase.PRODUCTION, "正在生成故事板与镜头画面", 2),
(QuickCreateJob.Phase.PRODUCTION, "正在生成视频（1/2）", 3),
(QuickCreateJob.Phase.COMPLETE, "视频已生成", 3),
]
for phase, message, expected in cases:
self.job.phase = phase
self.job.message = message
self.job.save(update_fields=["phase", "message", "updated_at"])
self.assertEqual(
QuickCreateJobSerializer(self.job).data["phase_index"],
expected,
msg=f"{phase} / {message}",
)
@patch("apps.projects.tasks.poll_video_segment_task.apply_async")
@patch("apps.projects.services.quick_create.submit_video_segment")
def test_video_start_uses_quick_create_core_parameters(self, submit_video, schedule_poll):
core/backend/apps/projects/views.py
+45 -1
View File
@@ -289,6 +289,12 @@ class ProjectViewSet(TeamScopedViewSetMixin, ModelViewSet):
group.adopted_asset = tri
group.save(update_fields=["adopted_asset", "updated_at"])
def list(self, request, *args, **kwargs):
from .services.quick_create import restore_false_failed_quick_creates
restore_false_failed_quick_creates(self.get_team())
return super().list(request, *args, **kwargs)
def retrieve(self, request, *args, **kwargs):
# 详情加载(=进入流水线页)时自愈视频片段数:历史项目在「采用前增删分镜」未同步,
# 或项目创建固定铺的 4 段从未被收口,会让视频步骤的片段数与故事板/采用版分镜对不上。
@@ -699,9 +705,47 @@ class ProjectViewSet(TeamScopedViewSetMixin, ModelViewSet):
job = self._quick_job_queryset().get(id=job.id)
return Response(QuickCreateJobSerializer(job).data)
@action(detail=False, methods=["post"], url_path=r"quick-create-retry/(?P<job_id>[^/.]+)")
def quick_create_retry(self, request, job_id=None):
job = self._quick_job_queryset().filter(id=job_id).first()
if job is None:
return Response({"detail": "极速成片任务不存在"}, status=status.HTTP_404_NOT_FOUND)
if job.status == QuickCreateJob.Status.SUCCEEDED:
return Response({"detail": "任务已完成"}, status=status.HTTP_400_BAD_REQUEST)
if job.status == QuickCreateJob.Status.CANCELLED:
return Response({"detail": "已取消的任务请重新开始"}, status=status.HTTP_400_BAD_REQUEST)
from .services.quick_create import resume_quick_create
resume_quick_create(job)
job = self._quick_job_queryset().get(id=job.id)
return Response(QuickCreateJobSerializer(job).data)
@action(detail=False, methods=["post"], url_path=r"quick-create-retry/(?P<job_id>[^/.]+)")
def quick_create_retry(self, request, job_id=None):
job = self._quick_job_queryset().filter(id=job_id).first()
if job is None:
return Response({"detail": "极速成片任务不存在"}, status=status.HTTP_404_NOT_FOUND)
if job.status == QuickCreateJob.Status.SUCCEEDED:
return Response({"detail": "任务已经完成"}, status=status.HTTP_400_BAD_REQUEST)
if job.status == QuickCreateJob.Status.CANCELLED:
return Response({"detail": "已取消的任务请重新开始"}, status=status.HTTP_400_BAD_REQUEST)
from .services.quick_create import resume_quick_create
resume_quick_create(job)
job = self._quick_job_queryset().get(id=job.id)
return Response(QuickCreateJobSerializer(job).data)
@action(detail=False, methods=["get"], url_path="quick-create-history")
def quick_create_history(self, request):
jobs = self._quick_job_queryset().filter(status=QuickCreateJob.Status.SUCCEEDED).order_by("-created_at")
from .services.quick_create import restore_false_failed_quick_creates
restore_false_failed_quick_creates(self.get_team())
# 进行中的任务看上方状态卡；列表要能找回失败后去专业模式继续的项目。
jobs = (
self._quick_job_queryset()
.exclude(status__in=[QuickCreateJob.Status.QUEUED, QuickCreateJob.Status.RUNNING])
.order_by("-created_at")
)
return Response({
"count": jobs.count(),
"results": QuickCreateJobSerializer(jobs[:30], many=True).data,