Merge pull request #118 from cbusillo/fix-size-followup-wrapper-and-approval

Fix size followup wrapper and approval gate

Author: shiny-code-bot

mediaforce/web/app.py

@@ -720,13 +720,15 @@ def _proposal_alignment_issue(
             current_policy: dict[str, Any],
             preview_policy: dict[str, Any],
             allow_measured_size_quality_tradeoff: bool = False,
+            allow_measured_size_quality_increase: bool = False,
     ) -> str | None:
         return proposal_alignment_issue(
             operator_request=operator_request,
             request_disposition=request_disposition,
             current_policy=current_policy,
             preview_policy=preview_policy,
             allow_measured_size_quality_tradeoff=allow_measured_size_quality_tradeoff,
+            allow_measured_size_quality_increase=allow_measured_size_quality_increase,
         )
 
     def _folder_ai_tune_deps() -> FolderAiTuneDeps:

mediaforce/web/runtime/folder_actions.py

@@ -94,6 +94,17 @@ def _high_impact_policy_change(current_policy: ActionPayload, draft_policy: Acti
     return False
 
 
+def _draft_raises_quality_target(current_policy: ActionPayload, draft_policy: ActionPayload) -> bool:
+    current_video = object_dict(current_policy.get("video"))
+    draft_video = object_dict(draft_policy.get("video"))
+    for key in ("target_vmaf", "target_xpsnr"):
+        current_value = _normalized_number(current_video.get(key))
+        draft_value = _normalized_number(draft_video.get(key))
+        if current_value is not None and draft_value is not None and draft_value > current_value + 0.01:
+            return True
+    return False
+
+
 class LoadFolderStagedItemsFn(Protocol):
     def __call__(
             self,
@@ -810,6 +821,12 @@ def save_profile_action(
         operator_request=operator_request or None,
         calibration_payload=calibration_payload,
     )
+    if (
+            allow_measured_size_quality_increase
+            and str(size_target_analysis.get("status") or "").strip() == "under_target"
+            and _draft_raises_quality_target(baseline_policy, object_dict(calibration_payload.get("policy")))
+    ):
+        size_issue = None
     if size_issue is not None and not confirm_size_tradeoff:
         raise HTTPException(status_code=409, detail=size_issue)
     if str(calibration_payload.get("mode") or "sample") == "sample":

tests/test_encode_queue_recovery.py

@@ -4912,6 +4912,53 @@ def test_save_profile_action_allows_explicit_size_tradeoff_approval(self) -> Non
         self.assertEqual(saved_payloads[0]["accepted_at"], "2026-05-24T04:40:00+00:00")
         self.assertTrue(merged_advice[0]["operator_approved_size_tradeoff"])
 
+    def test_save_profile_action_allows_under_target_quality_increase_without_tradeoff_confirmation(self) -> None:
+        saved_payloads: list[folder_actions_runtime.ActionPayload] = []
+        merged_advice: list[folder_actions_runtime.ActionPayload] = []
+        calibration_payload: folder_actions_runtime.ActionPayload = {
+            "mode": "sample",
+            "job_id": "sample-1",
+            "action": "ai_tune",
+            "review_media_ready": True,
+            "policy": {"video": {"target_vmaf": 95.0, "max_encoded_percent": 80}},
+            "sample_item": {
+                "library_item_id": 1,
+                "resolved_policy": {"video": {"target_vmaf": 92.0, "max_encoded_percent": 80}},
+            },
+            "sample_result": {"predicted_total_size_bytes": 250 * 1024 * 1024},
+        }
+
+        result = folder_actions_runtime.save_profile_action(
+            self.config,
+            "tv/show",
+            now_iso=lambda: "2026-05-24T04:40:00+00:00",
+            load_sample_item=lambda *_args, **_kwargs: None,
+            load_calibration_state=lambda *_args, **_kwargs: dict(calibration_payload),
+            calibration_draft_hash=web_app._calibration_draft_hash,
+            save_calibration_state=lambda _config, _prefix, payload: saved_payloads.append(dict(payload)),
+            load_advice_state=lambda *_args, **_kwargs: {
+                "request_disposition": "honored",
+                "operator_request": {
+                    "operator_confirmed": True,
+                    "request_type": "size_budget",
+                    "budget_bytes": 300 * 1024 * 1024,
+                    "budget_label": "300 MB per episode",
+                    "applied_policy": None,
+                },
+            },
+            record_visual_approval_artifact=lambda *_args, **_kwargs: {"artifact_id": "approval-1"},
+            merge_advice_state=lambda _config, _prefix, payload: merged_advice.append(dict(payload)),
+            upsert_override=lambda *_args, **_kwargs: None,
+            auto_queue_folder_encode=lambda *_args, **_kwargs: {"ok": True, "message": "Queued folder encode."},
+            confirm_high_impact=True,
+            reviewed_draft_hash=web_app._calibration_draft_hash(calibration_payload),
+        )
+
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["queued"])
+        self.assertEqual(saved_payloads[0]["accepted_at"], "2026-05-24T04:40:00+00:00")
+        self.assertFalse(merged_advice[0]["operator_approved_size_tradeoff"])
+
     def test_run_sampled_calibration_keeps_review_directory_for_approval(self) -> None:
         source_path = self._create_source_file("episode-review.mkv")
         preview_dir = self.config.paths.review_dir / "run-123" / "item-00"

tests/test_tuning_runtime.py

@@ -1354,6 +1354,52 @@ def test_completed_route_returns_payload(self) -> None:
         self.assertEqual(response.status_code, 200)
         self.assertEqual(json.loads(response.body), expected_payload)
 
+    def test_app_proposal_alignment_wrapper_accepts_quality_increase_flag(self) -> None:
+        from mediaforce.web import app as web_app
+
+        captured: list[dict[str, object]] = []
+
+        def fake_proposal_alignment_issue(**kwargs: object) -> None:
+            captured.append(dict(kwargs))
+            return None
+
+        def fake_preview_action(_config: MediaforceConfig, deps: FolderAiTuneDeps, *_args: object) -> dict[str, object]:
+            deps.proposal_alignment_issue(
+                operator_request={"request_type": "size_budget"},
+                request_disposition="honored",
+                current_policy={"video": {"target_vmaf": 92.0}},
+                preview_policy={"video": {"target_vmaf": 95.0}},
+                allow_measured_size_quality_increase=True,
+            )
+            return {"ok": True}
+
+        with patch("mediaforce.web.app.load_config", return_value=self.config), patch(
+                "mediaforce.web.app.purge_transient_artifacts"
+        ), patch("mediaforce.web.app._start_calibration_queue_worker"), patch(
+            "mediaforce.web.app._start_encode_queue_worker"
+        ), patch("mediaforce.web.app._refresh_host_status_cache", return_value=[]), patch(
+            "mediaforce.web.app.proposal_alignment_issue",
+            side_effect=fake_proposal_alignment_issue,
+        ), patch(
+            "mediaforce.web.app.folder_ai_tune_preview_action",
+            side_effect=fake_preview_action,
+        ):
+            app = web_app.create_app(self.root / "config.toml")
+            preview_route = next(
+                route
+                for route in app.routes
+                if isinstance(route, APIRoute) and route.path == "/api/folders/{prefix:path}/ai-tune/preview"
+            )
+
+            class _FakeRequest:
+                async def json(self) -> dict[str, str]:
+                    return {"note": "raise quality", "host_key": "host-1"}
+
+            response = asyncio.run(preview_route.endpoint("tv/show", _FakeRequest()))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(captured[0]["allow_measured_size_quality_increase"])
+
     def test_completed_cleanup_route_passes_selected_prefixes(self) -> None:
         from mediaforce.web import app as web_app