Initial commit
This commit is contained in:
commit
57fc3525eb
7311 files changed
+1291398
No files matched your search
@@ -0,0 +1,891 @@
|
||||
"""Dedicated Arena blind-test runner for GPT Image 2 C2PA detection."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import random
|
||||
import time
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
from app.services.arena_image_generation import (
|
||||
image_signatures as _image_signatures,
|
||||
read_image_bytes as _read_image_bytes,
|
||||
same_image as _same_image,
|
||||
)
|
||||
from app.core.driver import as_element, driver_for_tab
|
||||
|
||||
|
||||
GPT_IMAGE_MARKERS = (
|
||||
b"gpt-image",
|
||||
b"OpenAI Media Service API",
|
||||
b"OpenAI OpCo, LLC",
|
||||
)
|
||||
|
||||
ARENA_RESULT_IMAGE_SELECTOR = (
|
||||
"img.transition-opacity.duration-500.opacity-100.aspect-square.object-cover"
|
||||
)
|
||||
ARENA_AGENT_PAGE_PATH = "/agent"
|
||||
|
||||
|
||||
def inspect_gpt_image2_png(payload: bytes) -> dict[str, Any]:
|
||||
"""Return strong GPT Image 2 evidence found in a PNG C2PA caBX chunk."""
|
||||
data = bytes(payload or b"")
|
||||
if not data.startswith(b"\x89PNG\r\n\x1a\n"):
|
||||
return {"matched": False, "reason": "not_png", "markers": []}
|
||||
|
||||
offset = 8
|
||||
cabx_chunks: list[bytes] = []
|
||||
while offset + 12 <= len(data):
|
||||
length = int.from_bytes(data[offset : offset + 4], "big")
|
||||
chunk_type = data[offset + 4 : offset + 8]
|
||||
chunk_end = offset + 12 + length
|
||||
if chunk_end > len(data):
|
||||
return {"matched": False, "reason": "invalid_png", "markers": []}
|
||||
if chunk_type == b"caBX":
|
||||
cabx_chunks.append(data[offset + 8 : offset + 8 + length])
|
||||
offset = chunk_end
|
||||
if chunk_type == b"IEND":
|
||||
break
|
||||
|
||||
if not cabx_chunks:
|
||||
return {"matched": False, "reason": "c2pa_missing", "markers": []}
|
||||
|
||||
manifest = b"".join(cabx_chunks)
|
||||
marker_hits = [marker.decode("ascii") for marker in GPT_IMAGE_MARKERS if marker in manifest]
|
||||
# CBOR text values use one-byte length prefixes here: i=9 for gpt-image,
|
||||
# c=3 for 2.0. Requiring the adjacent fields prevents a stray version
|
||||
# elsewhere in the signed manifest from producing a false positive.
|
||||
has_model = b"dnameigpt-imagegversionc2.0" in manifest
|
||||
has_openai_claim = b"OpenAI Media Service API" in manifest
|
||||
matched = has_model and has_openai_claim
|
||||
return {
|
||||
"matched": matched,
|
||||
"reason": "gpt_image_2_c2pa" if matched else "c2pa_not_gpt_image_2",
|
||||
"markers": marker_hits,
|
||||
"caBX_bytes": len(manifest),
|
||||
}
|
||||
|
||||
|
||||
def _value(values: dict[str, Any], key: str, default: Any = "") -> Any:
|
||||
value = values.get(key, default)
|
||||
return default if value is None else value
|
||||
|
||||
|
||||
def _sleep(ctx: dict[str, Any], seconds: float, step: float = 0.2) -> None:
|
||||
deadline = time.time() + max(0.0, float(seconds))
|
||||
while time.time() < deadline:
|
||||
ctx["raise_if_cancelled"]()
|
||||
ctx["raise_if_command_loop_cancelled"]()
|
||||
agent_guard = ctx.get("_arena_agent_guard")
|
||||
if agent_guard and agent_guard():
|
||||
raise RuntimeError("arena_agent_redirected")
|
||||
ctx["reset_timeout"]()
|
||||
time.sleep(min(step, max(0.0, deadline - time.time())))
|
||||
|
||||
|
||||
def _current_url(tab: Any) -> str:
|
||||
try:
|
||||
return str(driver_for_tab(tab).run_js("return location.href") or "").strip()
|
||||
except Exception:
|
||||
return str(getattr(tab, "url", "") or "").strip()
|
||||
|
||||
|
||||
def _is_agent_page_url(url: str) -> bool:
|
||||
"""Return whether Arena has landed on its agent page, which is abnormal for this runner."""
|
||||
try:
|
||||
parsed = urlsplit(str(url or "").strip())
|
||||
return (
|
||||
parsed.scheme.lower() == "https"
|
||||
and parsed.netloc.lower() == "arena.ai"
|
||||
and parsed.path.rstrip("/") == ARENA_AGENT_PAGE_PATH
|
||||
)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _redirect_if_agent_page(ctx: dict[str, Any], redirect_url: str) -> bool:
|
||||
"""Redirect an unexpected /agent page and report whether the guard fired."""
|
||||
tab = ctx["tab"]
|
||||
current_url = _current_url(tab)
|
||||
if not _is_agent_page_url(current_url):
|
||||
return False
|
||||
|
||||
logger = ctx["logger"]
|
||||
logger.warning(
|
||||
f"[GPT-IMAGE-2] unexpected Arena agent page: {current_url}; "
|
||||
f"navigating to {redirect_url}"
|
||||
)
|
||||
try:
|
||||
tab.get(redirect_url)
|
||||
except Exception as navigate_error:
|
||||
logger.warning(
|
||||
"[GPT-IMAGE-2] agent-page redirect tab.get() failed, "
|
||||
f"falling back to location.replace(): {navigate_error}"
|
||||
)
|
||||
driver_for_tab(tab).run_js("location.replace(arguments[0])", redirect_url)
|
||||
return True
|
||||
|
||||
|
||||
def _same_page_url(current_url: str, target_url: str) -> bool:
|
||||
try:
|
||||
current = urlsplit(str(current_url or "").strip())
|
||||
target = urlsplit(str(target_url or "").strip())
|
||||
return (
|
||||
current.scheme.lower() == target.scheme.lower()
|
||||
and current.netloc.lower() == target.netloc.lower()
|
||||
and current.path.rstrip("/") == target.path.rstrip("/")
|
||||
)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _new_image_chat_ready(tab: Any, redirect_url: str) -> bool:
|
||||
if not _same_page_url(_current_url(tab), redirect_url):
|
||||
return False
|
||||
input_box = _find(tab, "css:textarea[name='message']", 1.0)
|
||||
if not input_box:
|
||||
return False
|
||||
try:
|
||||
return int(as_element(input_box).run_js("return String(this.value || '').length")) == 0
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _visible_image_sources(tab: Any) -> list[str]:
|
||||
script = f"""
|
||||
const collect = (images) => Array.from(images)
|
||||
.filter((img) => {{
|
||||
const r = img.getBoundingClientRect();
|
||||
const s = getComputedStyle(img);
|
||||
return img.isConnected && img.complete && img.naturalWidth >= 256
|
||||
&& img.naturalHeight >= 256 && r.width >= 120 && r.height >= 120
|
||||
&& s.display !== 'none' && s.visibility !== 'hidden';
|
||||
}});
|
||||
const resultImages = collect(document.querySelectorAll(
|
||||
{ARENA_RESULT_IMAGE_SELECTOR!r}
|
||||
));
|
||||
const images = resultImages.length ? resultImages : collect(document.images);
|
||||
return images
|
||||
.sort((a, b) => a.getBoundingClientRect().left - b.getBoundingClientRect().left)
|
||||
.map((img) => img.currentSrc || img.src)
|
||||
.filter(Boolean);
|
||||
"""
|
||||
try:
|
||||
return list(dict.fromkeys(str(item) for item in (driver_for_tab(tab).run_js(script) or []) if item))
|
||||
except Exception:
|
||||
return []
|
||||
|
||||
|
||||
def _log_image_url(url: str) -> str:
|
||||
try:
|
||||
parsed = urlsplit(str(url or ""))
|
||||
return f"{parsed.scheme}://{parsed.netloc}{parsed.path}"[:200]
|
||||
except Exception:
|
||||
return str(url or "").split("?", 1)[0][:200]
|
||||
|
||||
|
||||
def _find(tab: Any, selector: str, timeout: float = 1.0) -> Any:
|
||||
try:
|
||||
return driver_for_tab(tab).find(selector, timeout=timeout)
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def _upload_reference_image(ctx: dict[str, Any], path: str) -> bool:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
image_path = Path(os.path.expandvars(os.path.expanduser(path))).resolve()
|
||||
if not image_path.is_file():
|
||||
raise RuntimeError(f"reference_image_missing:{image_path}")
|
||||
|
||||
inputs = []
|
||||
try:
|
||||
inputs = list(driver_for_tab(tab).find_all('css:input[type="file"]', timeout=1.5) or [])
|
||||
except Exception:
|
||||
pass
|
||||
if not inputs:
|
||||
for selector in (
|
||||
"xpath://button[contains(., 'Upload') or contains(., '上传')]",
|
||||
"css:button[aria-label*='upload' i]",
|
||||
"css:button[aria-label*='image' i]",
|
||||
):
|
||||
button = _find(tab, selector, 0.5)
|
||||
if button:
|
||||
try:
|
||||
button.click()
|
||||
_sleep(ctx, 0.5)
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
inputs = list(driver_for_tab(tab).find_all('css:input[type="file"]', timeout=1.0) or [])
|
||||
except Exception:
|
||||
inputs = []
|
||||
if inputs:
|
||||
break
|
||||
|
||||
for file_input in inputs:
|
||||
try:
|
||||
file_input.input(str(image_path))
|
||||
logger.info(f"[GPT-IMAGE-2] reference image uploaded: {image_path.name}")
|
||||
_sleep(ctx, 2.0)
|
||||
return True
|
||||
except Exception as error:
|
||||
logger.debug(f"[GPT-IMAGE-2] file input upload failed: {error}")
|
||||
return False
|
||||
|
||||
|
||||
def _refresh_page(ctx: dict[str, Any]) -> None:
|
||||
tab = ctx["tab"]
|
||||
try:
|
||||
tab.refresh()
|
||||
except Exception:
|
||||
driver_for_tab(tab).run_js("location.reload()")
|
||||
_sleep(ctx, 2.0)
|
||||
|
||||
|
||||
def _is_generating(tab: Any) -> bool:
|
||||
try:
|
||||
result = driver_for_tab(tab).run_js(
|
||||
"""
|
||||
return (() => {
|
||||
const visible = (element) => {
|
||||
if (!(element instanceof HTMLElement) || !element.isConnected) return false;
|
||||
const rect = element.getBoundingClientRect();
|
||||
const style = getComputedStyle(element);
|
||||
return rect.width >= 8 && rect.height >= 8
|
||||
&& style.display !== 'none' && style.visibility !== 'hidden';
|
||||
};
|
||||
const hasStopButton = Array.from(document.querySelectorAll(
|
||||
'button[aria-label="Stop generation"], button[aria-label*="Stop" i], button[data-testid*="stop" i]'
|
||||
)).some(visible);
|
||||
if (hasStopButton) return true;
|
||||
return Array.from(document.querySelectorAll('main *, [role="main"] *'))
|
||||
.filter(visible)
|
||||
.some((element) => /^generating\\s+image(?:\\.\\.\\.)?$/i.test(
|
||||
String(element.textContent || '').trim()
|
||||
));
|
||||
})();
|
||||
"""
|
||||
)
|
||||
return result is True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _is_generation_stopped(tab: Any) -> bool:
|
||||
try:
|
||||
result = driver_for_tab(tab).run_js(
|
||||
"""
|
||||
return (() => {
|
||||
const visible = (element) => {
|
||||
if (!(element instanceof HTMLElement) || !element.isConnected) return false;
|
||||
const rect = element.getBoundingClientRect();
|
||||
const style = getComputedStyle(element);
|
||||
return rect.width >= 8 && rect.height >= 8
|
||||
&& rect.bottom > 0 && rect.right > 0
|
||||
&& rect.top < innerHeight && rect.left < innerWidth
|
||||
&& style.display !== 'none' && style.visibility !== 'hidden';
|
||||
};
|
||||
return Array.from(document.querySelectorAll('main *, [role="main"] *'))
|
||||
.filter(visible)
|
||||
.some((element) => /^generation\\s+stopped$/i.test(
|
||||
String(element.textContent || '').trim()
|
||||
));
|
||||
})();
|
||||
"""
|
||||
)
|
||||
return result is True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _stop_generation(ctx: dict[str, Any]) -> bool:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
for selector in (
|
||||
'css:button[aria-label="Stop generation"]',
|
||||
"css:button[aria-label*='Stop' i]",
|
||||
"css:button[data-testid*='stop' i]",
|
||||
):
|
||||
button = _find(tab, selector, 0.8)
|
||||
if not button:
|
||||
continue
|
||||
try:
|
||||
button.click()
|
||||
logger.warning("[GPT-IMAGE-2] generation still active after recovery minute; clicked stop")
|
||||
_sleep(ctx, 2.0)
|
||||
return True
|
||||
except Exception as error:
|
||||
logger.warning(f"[GPT-IMAGE-2] stop generation click failed: {error}")
|
||||
logger.error("[GPT-IMAGE-2] generation is active but stop button was not found")
|
||||
return False
|
||||
|
||||
|
||||
def _stop_generation_and_confirm(ctx: dict[str, Any]) -> bool:
|
||||
if not _stop_generation(ctx):
|
||||
return False
|
||||
deadline = time.time() + 5.0
|
||||
while time.time() < deadline:
|
||||
if _is_generation_stopped(ctx["tab"]) or not _is_generating(ctx["tab"]):
|
||||
return True
|
||||
_sleep(ctx, 0.25, 0.05)
|
||||
return False
|
||||
|
||||
|
||||
def _vote_a_better(ctx: dict[str, Any]) -> bool:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
script = r"""
|
||||
return (() => {
|
||||
const norm = (value) => String(value || '').replace(/\s+/g, ' ').trim().toLowerCase();
|
||||
const visible = (element) => {
|
||||
if (!(element instanceof HTMLElement) || !element.isConnected) return false;
|
||||
const rect = element.getBoundingClientRect();
|
||||
const style = getComputedStyle(element);
|
||||
return rect.width >= 8 && rect.height >= 8 && rect.bottom > 0 && rect.right > 0
|
||||
&& rect.top < innerHeight && rect.left < innerWidth
|
||||
&& style.display !== 'none' && style.visibility !== 'hidden'
|
||||
&& style.pointerEvents !== 'none' && Number(style.opacity || '1') > 0.2;
|
||||
};
|
||||
const matches = (text) => {
|
||||
const value = norm(text);
|
||||
return value.includes('a 更好') || value.includes('a is better')
|
||||
|| value === 'a better' || value.includes('← a');
|
||||
};
|
||||
const elements = Array.from(document.querySelectorAll('button, [role="button"]'));
|
||||
const button = elements.find((element) => {
|
||||
const text = element.innerText || element.textContent || element.getAttribute('aria-label');
|
||||
return visible(element) && !element.disabled
|
||||
&& element.getAttribute('aria-disabled') !== 'true' && matches(text);
|
||||
});
|
||||
if (!button) return false;
|
||||
button.scrollIntoView({block: 'center', inline: 'center'});
|
||||
button.click();
|
||||
return true;
|
||||
})();
|
||||
"""
|
||||
try:
|
||||
clicked = bool(driver_for_tab(tab).run_js(script))
|
||||
except Exception as error:
|
||||
logger.warning(f"[GPT-IMAGE-2] failed to click A better: {error}")
|
||||
return False
|
||||
if clicked:
|
||||
logger.info("[GPT-IMAGE-2] non-target result; selected A better")
|
||||
_sleep(ctx, 1.0)
|
||||
else:
|
||||
logger.warning("[GPT-IMAGE-2] non-target result; A better button was not found")
|
||||
return clicked
|
||||
|
||||
|
||||
def _start_new_image_chat(ctx: dict[str, Any], redirect_url: str) -> bool:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
selectors = (
|
||||
"css:a[href='/image']",
|
||||
"xpath://a[contains(., 'New Chat') or contains(., 'New chat')]",
|
||||
"xpath://button[contains(., 'New Chat') or contains(., 'New chat')]",
|
||||
)
|
||||
if _new_image_chat_ready(tab, redirect_url):
|
||||
logger.stream(f"[GPT-IMAGE-2] new image chat ready: url={_current_url(tab)}")
|
||||
return True
|
||||
|
||||
for selector in selectors:
|
||||
element = _find(tab, selector, 0.8)
|
||||
if not element:
|
||||
continue
|
||||
try:
|
||||
element.click()
|
||||
_sleep(ctx, 1.2)
|
||||
if _new_image_chat_ready(tab, redirect_url):
|
||||
logger.stream(f"[GPT-IMAGE-2] new image chat confirmed: url={_current_url(tab)}")
|
||||
return True
|
||||
except Exception:
|
||||
continue
|
||||
try:
|
||||
logger.stream(f"[GPT-IMAGE-2] New Chat not confirmed; navigating to {redirect_url}")
|
||||
tab.get(redirect_url)
|
||||
_sleep(ctx, 2.0)
|
||||
return _new_image_chat_ready(tab, redirect_url)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _send_prompt(
|
||||
ctx: dict[str, Any], prompt: str, *, require_clear_confirmation: bool = False
|
||||
) -> bool:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
input_box = _find(tab, "css:textarea[name='message']", 5.0)
|
||||
if not input_box:
|
||||
return False
|
||||
if require_clear_confirmation:
|
||||
try:
|
||||
replaced = as_element(input_box).run_js(
|
||||
"""
|
||||
const value = String(arguments[0] || '');
|
||||
const setter = Object.getOwnPropertyDescriptor(
|
||||
HTMLTextAreaElement.prototype, 'value'
|
||||
).set;
|
||||
this.focus();
|
||||
setter.call(this, value);
|
||||
this.dispatchEvent(new InputEvent('input', {
|
||||
bubbles: true,
|
||||
data: value,
|
||||
inputType: 'insertFromPaste'
|
||||
}));
|
||||
this.dispatchEvent(new Event('change', {bubbles: true}));
|
||||
this.setSelectionRange(value.length, value.length);
|
||||
return String(this.value || '');
|
||||
""",
|
||||
prompt,
|
||||
)
|
||||
except Exception as error:
|
||||
logger.error(f"[GPT-IMAGE-2] failed to replace composer text: {error}")
|
||||
return False
|
||||
if str(replaced or "") != prompt:
|
||||
logger.error("[GPT-IMAGE-2] composer replacement did not match the prompt")
|
||||
return False
|
||||
|
||||
stable_checks = 0
|
||||
deadline = time.time() + 1.5
|
||||
while time.time() < deadline:
|
||||
current_input = _find(tab, "css:textarea[name='message']", 0.3)
|
||||
try:
|
||||
current_value = str(
|
||||
as_element(current_input).run_js("return String(this.value || '')") if current_input else ""
|
||||
)
|
||||
except Exception:
|
||||
current_value = ""
|
||||
if current_value == prompt:
|
||||
stable_checks += 1
|
||||
if stable_checks >= 3:
|
||||
break
|
||||
else:
|
||||
stable_checks = 0
|
||||
_sleep(ctx, 0.15, 0.05)
|
||||
if stable_checks < 3:
|
||||
logger.error("[GPT-IMAGE-2] controlled composer restored or changed the prompt")
|
||||
return False
|
||||
|
||||
def composer_is_empty() -> bool:
|
||||
current_input = _find(tab, "css:textarea[name='message']", 0.3)
|
||||
if not current_input:
|
||||
return False
|
||||
try:
|
||||
return int(as_element(current_input).run_js("return String(this.value || '').length")) == 0
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
def wait_until_sent(timeout: float = 3.0) -> bool:
|
||||
deadline = time.time() + timeout
|
||||
while time.time() < deadline:
|
||||
if composer_is_empty():
|
||||
return True
|
||||
_sleep(ctx, 0.15, 0.05)
|
||||
return False
|
||||
|
||||
button = _find(
|
||||
tab,
|
||||
"css:button[aria-label='Send message'][type='submit']:not(:disabled), "
|
||||
"button[type='submit']:not([aria-label='Stop generation']):not(:disabled)",
|
||||
1.0,
|
||||
)
|
||||
if button:
|
||||
try:
|
||||
button.click()
|
||||
except Exception as error:
|
||||
logger.warning(f"[GPT-IMAGE-2] send button click failed: {error}")
|
||||
else:
|
||||
logger.warning("[GPT-IMAGE-2] send button not found")
|
||||
if wait_until_sent():
|
||||
logger.stream("[GPT-IMAGE-2] send confirmed after button click")
|
||||
return True
|
||||
|
||||
for enter_attempt in range(2):
|
||||
current_input = _find(tab, "css:textarea[name='message']", 0.5)
|
||||
if not current_input:
|
||||
logger.warning("[GPT-IMAGE-2] composer missing before Enter fallback")
|
||||
else:
|
||||
try:
|
||||
current_input.input("\n")
|
||||
except Exception as error:
|
||||
logger.warning(
|
||||
f"[GPT-IMAGE-2] Enter fallback failed: "
|
||||
f"attempt={enter_attempt + 1}/2 error={error}"
|
||||
)
|
||||
if wait_until_sent():
|
||||
logger.stream(
|
||||
f"[GPT-IMAGE-2] send confirmed after Enter: attempt={enter_attempt + 1}/2"
|
||||
)
|
||||
return True
|
||||
logger.warning(
|
||||
f"[GPT-IMAGE-2] composer still contains text after Enter: "
|
||||
f"attempt={enter_attempt + 1}/2"
|
||||
)
|
||||
return False
|
||||
|
||||
try:
|
||||
input_box.clear()
|
||||
except Exception:
|
||||
pass
|
||||
input_box.input(prompt)
|
||||
_sleep(ctx, 0.3)
|
||||
before_url = _current_url(tab)
|
||||
|
||||
def submission_confirmed(timeout: float = 2.0) -> bool:
|
||||
deadline = time.time() + timeout
|
||||
while time.time() < deadline:
|
||||
current_url = _current_url(tab)
|
||||
if current_url and current_url != before_url:
|
||||
return True
|
||||
try:
|
||||
if int(as_element(input_box).run_js("return String(this.value || '').length")) == 0:
|
||||
return True
|
||||
except Exception:
|
||||
pass
|
||||
for selector in (
|
||||
"css:button[aria-label*='Stop' i]",
|
||||
"css:button[data-testid*='stop' i]",
|
||||
"css:[aria-busy='true']",
|
||||
):
|
||||
if _find(tab, selector, 0.15):
|
||||
return True
|
||||
_sleep(ctx, 0.15, 0.05)
|
||||
return False
|
||||
|
||||
for attempt in range(2):
|
||||
try:
|
||||
input_box.input("\n")
|
||||
except Exception as error:
|
||||
if isinstance(error, RuntimeError) and "cancelled" in str(error).lower():
|
||||
raise
|
||||
logger.warning(
|
||||
f"[GPT-IMAGE-2] Enter submit failed: attempt={attempt + 1}/2 error={error}"
|
||||
)
|
||||
if submission_confirmed(2.5):
|
||||
logger.stream(f"[GPT-IMAGE-2] Enter submit confirmed: attempt={attempt + 1}/2")
|
||||
return True
|
||||
if attempt == 0:
|
||||
logger.stream("[GPT-IMAGE-2] Enter submit not confirmed; retrying Enter")
|
||||
_sleep(ctx, 0.5)
|
||||
|
||||
button = _find(tab, "css:button[type='submit']", 1.0)
|
||||
if button:
|
||||
try:
|
||||
logger.stream("[GPT-IMAGE-2] Enter submit not confirmed; trying send button")
|
||||
button.click()
|
||||
if submission_confirmed(2.5):
|
||||
logger.stream("[GPT-IMAGE-2] send button submit confirmed")
|
||||
return True
|
||||
except Exception as error:
|
||||
logger.warning(f"[GPT-IMAGE-2] send button fallback failed: {error}")
|
||||
return False
|
||||
|
||||
|
||||
def _wait_for_gpt_image2(
|
||||
ctx: dict[str, Any],
|
||||
baseline: set[str],
|
||||
timeout: float,
|
||||
reference_signature: dict[str, Any] | None = None,
|
||||
) -> tuple[list[dict[str, Any]], list[str]]:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
deadline = time.time() + timeout
|
||||
inspected: dict[str, str] = {}
|
||||
matches: list[dict[str, Any]] = []
|
||||
candidates: list[str] = []
|
||||
last_new_image_at = 0.0
|
||||
|
||||
while time.time() < deadline:
|
||||
_sleep(ctx, 0.5)
|
||||
sources = [url for url in _visible_image_sources(tab) if url not in baseline]
|
||||
if sources:
|
||||
last_new_image_at = last_new_image_at or time.time()
|
||||
for side_index, url in enumerate(sources):
|
||||
if url in inspected:
|
||||
continue
|
||||
payload = _read_image_bytes(tab, url)
|
||||
if not payload:
|
||||
continue
|
||||
signatures = _image_signatures(payload)
|
||||
inspected[url] = signatures["sha256"]
|
||||
if _same_image(signatures, reference_signature):
|
||||
logger.info(
|
||||
f"[GPT-IMAGE-2] skipped submitted reference image: "
|
||||
f"side={'A' if side_index == 0 else 'B'} "
|
||||
f"url={_log_image_url(url)}"
|
||||
)
|
||||
continue
|
||||
if url not in candidates:
|
||||
candidates.append(url)
|
||||
evidence = inspect_gpt_image2_png(payload)
|
||||
logger.info(
|
||||
f"[GPT-IMAGE-2][C2PA] side={'A' if side_index == 0 else 'B'} "
|
||||
f"matched={evidence['matched']} reason={evidence['reason']} "
|
||||
f"bytes={len(payload)} url={_log_image_url(url)}"
|
||||
)
|
||||
if evidence["matched"]:
|
||||
matches.append({"url": url, "side": "A" if side_index == 0 else "B", **evidence})
|
||||
generation_done = _is_generation_stopped(tab) or not _is_generating(tab)
|
||||
if (
|
||||
last_new_image_at
|
||||
and time.time() - last_new_image_at >= 4.0
|
||||
and generation_done
|
||||
):
|
||||
# Arena can reuse a URL while replacing an early preview with the
|
||||
# final PNG, so force one content-aware pass after generation ends.
|
||||
final_sources = [
|
||||
url for url in _visible_image_sources(tab) if url not in baseline
|
||||
]
|
||||
for side_index, url in enumerate(final_sources):
|
||||
payload = _read_image_bytes(tab, url)
|
||||
if not payload:
|
||||
continue
|
||||
signatures = _image_signatures(payload)
|
||||
final_side = "A" if side_index == 0 else "B"
|
||||
if inspected.get(url) == signatures["sha256"]:
|
||||
for match in matches:
|
||||
if match.get("url") == url:
|
||||
match["side"] = final_side
|
||||
continue
|
||||
inspected[url] = signatures["sha256"]
|
||||
if _same_image(signatures, reference_signature):
|
||||
continue
|
||||
if url not in candidates:
|
||||
candidates.append(url)
|
||||
evidence = inspect_gpt_image2_png(payload)
|
||||
logger.info(
|
||||
f"[GPT-IMAGE-2][C2PA][FINAL] "
|
||||
f"side={final_side} "
|
||||
f"matched={evidence['matched']} reason={evidence['reason']} "
|
||||
f"bytes={len(payload)} url={_log_image_url(url)}"
|
||||
)
|
||||
if evidence["matched"]:
|
||||
matches.append(
|
||||
{
|
||||
"url": url,
|
||||
"side": final_side,
|
||||
**evidence,
|
||||
}
|
||||
)
|
||||
break
|
||||
unique_matches = list(
|
||||
{item.get("url", ""): item for item in matches if item.get("url")}.values()
|
||||
)
|
||||
return unique_matches, candidates
|
||||
|
||||
|
||||
def _recover_timed_out_generation(
|
||||
ctx: dict[str, Any],
|
||||
initial_matches: list[dict[str, Any]],
|
||||
initial_candidates: list[str],
|
||||
reference_signature: dict[str, Any] | None = None,
|
||||
) -> tuple[list[dict[str, Any]], list[str], bool]:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
matches = list(initial_matches)
|
||||
candidates = list(initial_candidates)
|
||||
|
||||
_refresh_page(ctx)
|
||||
if _is_generating(tab):
|
||||
logger.warning("[GPT-IMAGE-2] generation still active after refresh; stopping immediately")
|
||||
if not _stop_generation_and_confirm(ctx):
|
||||
raise _StopGenerationFailure(
|
||||
"generation_still_active_after_stop; command loop terminated"
|
||||
)
|
||||
logger.info("[GPT-IMAGE-2] timed-out generation stopped; continuing next round")
|
||||
return matches, candidates, True
|
||||
else:
|
||||
logger.info("[GPT-IMAGE-2] generation completed after refresh; inspecting current images")
|
||||
recovered_matches, recovered_candidates = _wait_for_gpt_image2(
|
||||
ctx, set(), 5.0, reference_signature
|
||||
)
|
||||
matches.extend(recovered_matches)
|
||||
candidates.extend(recovered_candidates)
|
||||
|
||||
unique_matches = list({item.get("url", ""): item for item in matches if item.get("url")}.values())
|
||||
unique_candidates = list(dict.fromkeys(url for url in candidates if url))
|
||||
return unique_matches, unique_candidates, False
|
||||
|
||||
|
||||
class _StopGenerationFailure(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
def run(ctx: dict[str, Any], *, single_mode: bool = False) -> str:
|
||||
tab = ctx["tab"]
|
||||
logger = ctx["logger"]
|
||||
session = ctx.get("session")
|
||||
current_command_id = str(getattr(session, "_current_command_id", "") or "").strip()
|
||||
current_command_name = str(getattr(session, "current_command_name", "") or "").strip()
|
||||
single_mode = bool(
|
||||
single_mode
|
||||
or current_command_id == "cmd_15d91034"
|
||||
or current_command_name == "ARENA自动盲测不翻牌 -gpt image 2 - 单"
|
||||
)
|
||||
ui = ctx.get("command_ui") if isinstance(ctx.get("command_ui"), dict) else {}
|
||||
values = ui.get("values") if isinstance(ui.get("values"), dict) else ui
|
||||
values = values if isinstance(values, dict) else {}
|
||||
|
||||
total_runs = max(1, int(_value(values, "total_runs", 20)))
|
||||
prompt = str(_value(values, "prompt_text", "Create an image.")).strip()
|
||||
random_chars = str(_value(values, "random_insert_chars", "abcdefghijklmnopqrstuvwxyz"))
|
||||
reference_image = str(_value(values, "reference_image", "")).strip()
|
||||
reference_signature = None
|
||||
if reference_image:
|
||||
reference_path = Path(
|
||||
os.path.expandvars(os.path.expanduser(reference_image))
|
||||
).resolve()
|
||||
if reference_path.is_file():
|
||||
reference_signature = _image_signatures(reference_path.read_bytes())
|
||||
generation_mode = "image-to-image" if reference_image else "text-to-image"
|
||||
timeout = 150.0 if single_mode else min(
|
||||
100.0,
|
||||
max(1.0, float(_value(values, "wait_reply_timeout_sec", 100))),
|
||||
)
|
||||
redirect_url = str(_value(values, "redirect_url", "https://arena.ai/image")).strip()
|
||||
ctx["_arena_agent_guard"] = lambda: _redirect_if_agent_page(ctx, redirect_url)
|
||||
hit_urls: list[str] = []
|
||||
consecutive_send_failures = 0
|
||||
|
||||
logger.stream(
|
||||
f"[GPT-IMAGE-2] starting {total_runs} rounds; "
|
||||
f"mode={generation_mode}; timeout={timeout:g}s"
|
||||
)
|
||||
for index in range(total_runs):
|
||||
status = "completed"
|
||||
ctx["begin_command_loop"](index + 1, total_runs, "Arena GPT Image 2")
|
||||
try:
|
||||
if _redirect_if_agent_page(ctx, redirect_url):
|
||||
raise RuntimeError("arena_agent_redirected")
|
||||
if not single_mode:
|
||||
logger.stream(
|
||||
f"[GPT-IMAGE-2] round {index + 1}/{total_runs}: creating a new image chat"
|
||||
)
|
||||
if not _start_new_image_chat(ctx, redirect_url):
|
||||
raise RuntimeError("new_image_chat_failed")
|
||||
if reference_image and not _upload_reference_image(ctx, reference_image):
|
||||
raise RuntimeError("reference_image_upload_failed")
|
||||
|
||||
baseline = set(_visible_image_sources(tab))
|
||||
run_prompt = prompt
|
||||
if random_chars:
|
||||
position = random.randint(0, len(run_prompt))
|
||||
run_prompt = run_prompt[:position] + random.choice(random_chars) + run_prompt[position:]
|
||||
logger.stream(f"[GPT-IMAGE-2] round {index + 1}/{total_runs}: sending prompt")
|
||||
if not _send_prompt(
|
||||
ctx,
|
||||
run_prompt,
|
||||
require_clear_confirmation=single_mode,
|
||||
):
|
||||
if not single_mode:
|
||||
raise RuntimeError("send_failed")
|
||||
consecutive_send_failures += 1
|
||||
status = "failed"
|
||||
logger.error(
|
||||
f"[GPT-IMAGE-2] send failed {consecutive_send_failures} consecutive rounds; "
|
||||
"recovering the stuck page before the next round"
|
||||
)
|
||||
_refresh_page(ctx)
|
||||
if _is_generating(tab):
|
||||
logger.warning(
|
||||
"[GPT-IMAGE-2] stale generation remained after failed send; stopping it"
|
||||
)
|
||||
if not _stop_generation_and_confirm(ctx):
|
||||
raise _StopGenerationFailure(
|
||||
"generation_still_active_after_stop; command loop terminated"
|
||||
)
|
||||
continue
|
||||
consecutive_send_failures = 0
|
||||
|
||||
matches, candidates = _wait_for_gpt_image2(
|
||||
ctx, baseline, timeout, reference_signature
|
||||
)
|
||||
if single_mode and not matches and _is_generation_stopped(tab):
|
||||
logger.info(
|
||||
f"[GPT-IMAGE-2] round {index + 1}/{total_runs} generation stopped "
|
||||
"without a target match; continuing next round without voting"
|
||||
)
|
||||
continue
|
||||
if single_mode and (_is_generating(tab) or not candidates):
|
||||
logger.warning(
|
||||
f"[GPT-IMAGE-2] round {index + 1}/{total_runs} reached {timeout:g}s "
|
||||
"without a completed image response; refreshing within the same round"
|
||||
)
|
||||
matches, candidates, interrupted = _recover_timed_out_generation(
|
||||
ctx, matches, candidates, reference_signature
|
||||
)
|
||||
if interrupted:
|
||||
continue
|
||||
page_url = _current_url(tab)
|
||||
if matches:
|
||||
info = {
|
||||
"url": page_url,
|
||||
"response_sides": [
|
||||
f"gpt-image 2.0 OpenAI Media Service API mode:{generation_mode}"
|
||||
if item["side"] == side else "other image model"
|
||||
for side in ("A", "B")
|
||||
for item in matches[:1]
|
||||
],
|
||||
}
|
||||
record_result = ctx["record_arena_rule_candidates"](
|
||||
info,
|
||||
run_prompt,
|
||||
source="image-c2pa/gpt-image-2",
|
||||
)
|
||||
if page_url and page_url not in hit_urls:
|
||||
hit_urls.append(page_url)
|
||||
logger.info(
|
||||
f"[GPT-IMAGE-2][HIT] sides={','.join(item['side'] for item in matches)} "
|
||||
f"url={page_url} drawer_matches={record_result.get('matched', 0)}"
|
||||
)
|
||||
if single_mode:
|
||||
break
|
||||
elif single_mode:
|
||||
logger.info(
|
||||
f"[GPT-IMAGE-2] no GPT Image 2 C2PA match; images={len(candidates)} url={page_url}"
|
||||
)
|
||||
if candidates:
|
||||
_vote_a_better(ctx)
|
||||
else:
|
||||
logger.info(
|
||||
f"[GPT-IMAGE-2] no GPT Image 2 C2PA match; images={len(candidates)} url={page_url}"
|
||||
)
|
||||
except _StopGenerationFailure:
|
||||
status = "failed"
|
||||
raise
|
||||
except RuntimeError as error:
|
||||
if str(error) in {"python_script_cancelled", "python_script_loop_cancelled"}:
|
||||
status = "cancelled"
|
||||
if str(error) == "python_script_cancelled":
|
||||
break
|
||||
elif str(error) == "arena_agent_redirected":
|
||||
status = "failed"
|
||||
logger.warning(
|
||||
f"[GPT-IMAGE-2] round {index + 1} treated as abnormal because the page was /agent"
|
||||
)
|
||||
else:
|
||||
status = "failed"
|
||||
logger.error(f"[GPT-IMAGE-2] round {index + 1} failed: {error}")
|
||||
if not single_mode:
|
||||
try:
|
||||
tab.get(redirect_url)
|
||||
_sleep(ctx, 2.0)
|
||||
except Exception:
|
||||
pass
|
||||
except Exception as error:
|
||||
status = "failed"
|
||||
logger.error(f"[GPT-IMAGE-2] round {index + 1} failed: {error}")
|
||||
finally:
|
||||
ctx["end_command_loop"](status)
|
||||
|
||||
if hit_urls:
|
||||
return "GPT Image 2 C2PA hit URLs:\n" + "\n".join(
|
||||
f"{index}. {url}" for index, url in enumerate(hit_urls, 1)
|
||||
)
|
||||
return "GPT Image 2 C2PA hits: 0"
|
||||
|
||||
|
||||
__all__ = ["GPT_IMAGE_MARKERS", "inspect_gpt_image2_png", "run"]
|
||||
Reference in new issue
Block a user