purewhiter--mobilegym
wehub-resource-sync
598 行
19 KiB
Python
598 行
19 KiB
Python
import datetime
|
||
import re
|
||
from typing import Any, Iterable, Optional
|
||
|
||
import requests
|
||
|
||
|
||
_CITY_ALIASES: dict[str, list[str]] = {
|
||
"北京": ["北京", "北京市", "beijing"],
|
||
"上海": ["上海", "上海市", "shanghai"],
|
||
"广州": ["广州", "广州市", "guangzhou"],
|
||
"深圳": ["深圳", "深圳市", "shenzhen"],
|
||
"杭州": ["杭州", "杭州市", "hangzhou"],
|
||
"成都": ["成都", "成都市", "chengdu"],
|
||
"三亚": ["三亚", "三亚市", "sanya"],
|
||
"京都": ["京都", "kyoto"],
|
||
}
|
||
|
||
|
||
def clean_text(text: str) -> str:
|
||
"""统一自 crossapp/tasks.py、crossapp2/tasks.py。"""
|
||
if not text:
|
||
return ""
|
||
# 去掉非单词字符、非中文（包括空格）
|
||
# \u4fdd\u7559 \w + CJK + \u5e38\u7528 emoji \u5757\uff1b\u5220\u9664\u6807\u70b9/\u5168\u534a\u89d2\u7b26\u53f7/\u7a7a\u683c\u3002
|
||
# \u4fdd\u7559 emoji \u662f\u4e3a\u4e86\u8ba9"\u590d\u5236 title"\u7c7b\u4efb\u52a1\u80fd\u5224\u5b9a Agent \u662f\u5426\u5b8c\u6574\u590d\u5236\u5e26 emoji \u7684\u6807\u9898
|
||
# (emoji \u662f\u6570\u636e\u8bed\u4e49\u7684\u4e00\u90e8\u5206\uff0c\u4e0d\u5e94\u88ab norm \u541e\u6389)\u3002
|
||
# U+1F300-1FAFF: \u4e3b emoji \u533a (Pictographs / Emoticons / Symbols Extended-A/B)
|
||
# U+2600-27BF: Misc Symbols + Dingbats (\u2600 \u2728 \u2713 \u2b50 etc.)
|
||
text = re.sub(
|
||
r"[^\w\u4e00-\u9fff\U0001F300-\U0001FAFF\u2600-\u27bf]",
|
||
"",
|
||
text,
|
||
).replace("_", "").strip()
|
||
return text
|
||
|
||
|
||
def norm(s: str) -> str:
|
||
"""统一自 crossapp/tasks.py、crossapp2/tasks.py、spotify/tasks.py。"""
|
||
return clean_text(str(s or "")).lower()
|
||
|
||
|
||
# ── Traditional → Simplified Chinese mapping (opencc) ─────────────────
|
||
_t2s_converter = None
|
||
|
||
def _get_t2s():
|
||
global _t2s_converter
|
||
if _t2s_converter is None:
|
||
try:
|
||
import opencc
|
||
except ModuleNotFoundError as e:
|
||
raise ModuleNotFoundError(
|
||
"Missing dependency 'opencc-python-reimplemented'. Install:\n"
|
||
" pip install opencc-python-reimplemented"
|
||
) from e
|
||
_t2s_converter = opencc.OpenCC('t2s')
|
||
return _t2s_converter
|
||
|
||
|
||
def to_simplified(s: str) -> str:
|
||
"""Convert traditional Chinese to simplified via opencc t2s."""
|
||
if not s:
|
||
return s
|
||
return _get_t2s().convert(s)
|
||
|
||
|
||
def to_float(v: Any) -> Optional[float]:
|
||
"""统一自 weather/tasks.py、crossapp/tasks.py、crossapp2/tasks.py。"""
|
||
try:
|
||
return float(str(v).strip())
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
def extract_numbers(text: str) -> list[float]:
|
||
"""统一自 crossapp3/tasks.py、spe_tasks/tasks.py、ebay/tasks.py。"""
|
||
# 仅把 ASCII 单词字符视作数字边界，允许“余额是100.23元”这类中文包裹的数值被识别。
|
||
nums = re.findall(
|
||
r"(?<![0-9A-Za-z_.])(-?(?:\d{1,3}(?:[，,]\d{3})+|\d+)(?:\.\d+)?)(?![0-9A-Za-z_.])",
|
||
text or "",
|
||
)
|
||
out: list[float] = []
|
||
for n in nums:
|
||
try:
|
||
out.append(float(n.replace(",", "").replace("，", "")))
|
||
except Exception:
|
||
continue
|
||
return out
|
||
|
||
|
||
def city_aliases(city_name: str) -> list[str]:
|
||
"""返回城市名的多种匹配变体（包含本身）。"""
|
||
key = city_name.strip()
|
||
if key in _CITY_ALIASES:
|
||
return _CITY_ALIASES[key]
|
||
lowered = key.lower()
|
||
for canonical, aliases in _CITY_ALIASES.items():
|
||
if lowered in aliases or lowered == canonical.lower():
|
||
return aliases
|
||
return [key]
|
||
|
||
|
||
def amount_labels(value: float) -> list[str]:
|
||
"""生成金额的多种文本表示，用于子串匹配。"""
|
||
rounded = round(float(value), 2)
|
||
labels = {
|
||
f"{rounded:.2f}",
|
||
f"{rounded:.1f}",
|
||
f"{rounded:g}",
|
||
str(int(rounded)) if float(rounded).is_integer() else f"{rounded:g}",
|
||
}
|
||
return [label for label in labels if label]
|
||
|
||
|
||
_CN_DIGITS = "零一二三四五六七八九"
|
||
_CN_SMALL_UNITS = ["", "十", "百", "千"]
|
||
_CN_GROUP_UNITS = ["", "万", "亿", "兆"]
|
||
|
||
|
||
def _int_to_chinese_group(value: int) -> str:
|
||
if value == 0:
|
||
return "零"
|
||
|
||
parts: list[str] = []
|
||
zero_pending = False
|
||
digits = f"{value:04d}"
|
||
for index, ch in enumerate(digits):
|
||
digit = int(ch)
|
||
unit_index = 3 - index
|
||
if digit == 0:
|
||
if parts:
|
||
zero_pending = True
|
||
continue
|
||
if zero_pending:
|
||
parts.append("零")
|
||
zero_pending = False
|
||
parts.append(_CN_DIGITS[digit])
|
||
parts.append(_CN_SMALL_UNITS[unit_index])
|
||
return "".join(parts) or "零"
|
||
|
||
|
||
def int_to_chinese(value: int) -> str:
|
||
"""把整数转换为中文数字，如 33 -> 三十三，36650 -> 三万六千六百五十。"""
|
||
number = int(value)
|
||
if number == 0:
|
||
return "零"
|
||
if number < 0:
|
||
return f"负{int_to_chinese(-number)}"
|
||
|
||
groups: list[int] = []
|
||
while number > 0:
|
||
groups.append(number % 10000)
|
||
number //= 10000
|
||
|
||
parts: list[str] = []
|
||
zero_between = False
|
||
for group_index in range(len(groups) - 1, -1, -1):
|
||
group = groups[group_index]
|
||
if group == 0:
|
||
zero_between = bool(parts)
|
||
continue
|
||
if parts and (zero_between or group < 1000):
|
||
parts.append("零")
|
||
parts.append(_int_to_chinese_group(group))
|
||
parts.append(_CN_GROUP_UNITS[group_index])
|
||
zero_between = False
|
||
|
||
result = "".join(parts)
|
||
if result.startswith("一十"):
|
||
return result[1:]
|
||
return result
|
||
|
||
|
||
def integer_labels(value: int) -> list[str]:
|
||
"""生成整数的多种文本表示，用于 judge 匹配。"""
|
||
number = int(value)
|
||
labels = {
|
||
str(number),
|
||
f"{number:,}",
|
||
f"{number:,}".replace(",", "，"),
|
||
int_to_chinese(number),
|
||
}
|
||
return [label for label in labels if label]
|
||
|
||
|
||
def count_titles_in_text(text: str, titles: Iterable[str]) -> int:
|
||
"""统计 titles 中有多少个标题出现在 text 中。"""
|
||
return sum(1 for title in titles if title and title in text)
|
||
|
||
|
||
def parse_distance_to_meters(distance_text: Any) -> Optional[float]:
|
||
"""统一自 crossapp/tasks.py、crossapp3/tasks.py。"""
|
||
s = str(distance_text or "").strip().lower()
|
||
if not s:
|
||
return None
|
||
m = re.search(r"(\d+(?:\.\d+)?)", s)
|
||
if not m:
|
||
return None
|
||
try:
|
||
v = float(m.group(1))
|
||
except Exception:
|
||
return None
|
||
if "mi" in s or "mile" in s:
|
||
return v * 1609.344
|
||
if "km" in s or "公里" in s:
|
||
return v * 1000.0
|
||
if "m" in s or "米" in s:
|
||
return v
|
||
return v
|
||
|
||
|
||
def parse_duration_to_minutes(duration_text: Any) -> Optional[float]:
|
||
"""统一自 crossapp/tasks.py。"""
|
||
s = str(duration_text or "").strip().lower()
|
||
if not s:
|
||
return None
|
||
nums = re.findall(r"(\d+(?:\.\d+)?)", s)
|
||
if not nums:
|
||
return None
|
||
vals: list[float] = []
|
||
for x in nums:
|
||
try:
|
||
vals.append(float(x))
|
||
except Exception:
|
||
continue
|
||
if not vals:
|
||
return None
|
||
if "小时" in s or "hr" in s or "hour" in s:
|
||
if len(vals) >= 2 and ("分钟" in s or "min" in s):
|
||
return vals[0] * 60.0 + vals[1]
|
||
return vals[0] * 60.0
|
||
return vals[0]
|
||
|
||
|
||
def parse_duration_to_seconds(duration_text: Any) -> Optional[int]:
|
||
"""Parse a human-readable duration string to total seconds.
|
||
|
||
Recognises Chinese (小时/分钟/秒) and English (h/hr/min/sec/…) units.
|
||
Returns None when the text is empty or contains no recognisable units.
|
||
"""
|
||
text = str(duration_text or "").strip()
|
||
if not text:
|
||
return None
|
||
total = 0
|
||
for pattern, multiplier in (
|
||
(r"(\d+(?:\.\d+)?)\s*(?:小时|hr|hours?|h)", 3600),
|
||
(r"(\d+(?:\.\d+)?)\s*(?:分钟|mins?|minutes?|m)", 60),
|
||
(r"(\d+(?:\.\d+)?)\s*(?:秒|secs?|seconds?|s)", 1),
|
||
):
|
||
m = re.search(pattern, text, re.I)
|
||
if m:
|
||
total += int(float(m.group(1)) * multiplier)
|
||
return total or None
|
||
|
||
|
||
def now_ms(os_state: dict) -> int:
|
||
"""从 os_state 中提取模拟时间戳（毫秒）。禁止 fallback 到本地时间。"""
|
||
t = (os_state or {}).get("time")
|
||
if isinstance(t, (int, float)):
|
||
return int(t)
|
||
if isinstance(t, dict):
|
||
ts = t.get("timestamp")
|
||
if isinstance(ts, (int, float)):
|
||
return int(ts)
|
||
raise ValueError(
|
||
"os_state 中缺少 time 或 time.timestamp 字段，无法获取模拟时间。"
|
||
" 请确保 bench_env 正确读取了 __SIM__.getState() 的 os.time。"
|
||
)
|
||
|
||
|
||
def sim_today(os_state: dict) -> datetime.date:
|
||
"""从 os_state 中提取模拟日期。禁止 fallback 到本地时间。"""
|
||
return datetime.date.fromtimestamp(now_ms(os_state) / 1000.0)
|
||
|
||
|
||
def sim_datetime(os_state: dict) -> datetime.datetime:
|
||
"""从 os_state 中提取模拟 datetime。禁止 fallback 到本地时间。"""
|
||
return datetime.datetime.fromtimestamp(now_ms(os_state) / 1000.0)
|
||
|
||
|
||
def today_ymd(os_state: dict) -> str:
|
||
"""统一自 spe_tasks/tasks.py。"""
|
||
d = sim_today(os_state)
|
||
return f"{d.year:04d}-{d.month:02d}-{d.day:02d}"
|
||
|
||
|
||
def tomorrow_ymd(os_state: dict) -> str:
|
||
"""统一自 spe_tasks/tasks.py。"""
|
||
d = sim_today(os_state) + datetime.timedelta(days=1)
|
||
return f"{d.year:04d}-{d.month:02d}-{d.day:02d}"
|
||
|
||
|
||
def default_tomorrow() -> str:
|
||
"""Callable default: 基于真实时间的明天 ISO 日期，用于 parameters default。"""
|
||
return (datetime.date.today() + datetime.timedelta(days=1)).isoformat()
|
||
|
||
|
||
def sample_future_date(env_state: dict, rng) -> str:
|
||
"""Callable sampler: 基于模拟时间采样未来 1-13 天的 ISO 日期。"""
|
||
base = sim_today((env_state.get("os") or {}))
|
||
offset = rng.choice(range(1, 14))
|
||
return (base + datetime.timedelta(days=offset)).isoformat()
|
||
|
||
|
||
_WEEKDAY_ZH = ["一", "二", "三", "四", "五", "六", "日"]
|
||
|
||
|
||
def format_date_natural(value: str, env_state: dict) -> str:
|
||
"""Display formatter: 明天/后天/这周X/下周X/X月X号（基于模拟时间）。"""
|
||
parts = str(value).split("-")
|
||
if len(parts) != 3:
|
||
return str(value)
|
||
target = datetime.date(int(parts[0]), int(parts[1]), int(parts[2]))
|
||
today = sim_today(env_state.get("os") or {})
|
||
delta = (target - today).days
|
||
if delta == 1:
|
||
return "明天"
|
||
if delta == 2:
|
||
return "后天"
|
||
target_wd = target.weekday()
|
||
today_wd = today.weekday()
|
||
days_to_next_monday = 7 - today_wd
|
||
if 0 < delta <= (6 - today_wd):
|
||
return f"这周{_WEEKDAY_ZH[target_wd]}"
|
||
if days_to_next_monday <= delta <= days_to_next_monday + 6:
|
||
return f"下周{_WEEKDAY_ZH[target_wd]}"
|
||
return f"{target.month}月{target.day}号"
|
||
|
||
|
||
def normalize_price(value: float) -> int | float:
|
||
"""统一金额显示：保留两位小数，整数则返回 int。"""
|
||
rounded = round(float(value), 2)
|
||
return int(rounded) if rounded == int(rounded) else rounded
|
||
|
||
|
||
def day_bounds_ms(d: datetime.date) -> tuple[int, int]:
|
||
"""统一自 crossapp3/tasks.py。"""
|
||
start = datetime.datetime(d.year, d.month, d.day, 0, 0, 0)
|
||
end = start + datetime.timedelta(days=1)
|
||
return int(start.timestamp() * 1000), int(end.timestamp() * 1000)
|
||
|
||
|
||
def day_time_ms(d: datetime.date, time_text: str = "00:00") -> int:
|
||
"""返回指定模拟本地日期和 HH:MM 时间对应的毫秒时间戳。"""
|
||
hour, minute = [int(part) for part in time_text.split(":")]
|
||
dt = datetime.datetime(d.year, d.month, d.day, hour, minute)
|
||
return int(dt.timestamp() * 1000)
|
||
|
||
|
||
def opened_app_since_init(os_state: dict, os_init_state: dict, app_id: str) -> bool:
|
||
"""Check whether *app_id* was opened after task start."""
|
||
current_running = os_state["runningApps"]
|
||
initial_running = os_init_state["runningApps"]
|
||
return app_id in current_running and app_id not in initial_running
|
||
|
||
|
||
def norm_city_key(s: Any) -> str:
|
||
"""统一自 weather/tasks.py、crossapp/tasks.py、crossapp2/tasks.py。"""
|
||
s = str(s or "").strip().lower()
|
||
s = re.sub(r"\s+", "", s)
|
||
if s.endswith("市"):
|
||
s = s[:-1]
|
||
return s
|
||
|
||
|
||
def parse_date(value: str) -> datetime.date | None:
|
||
"""统一自 crossapp3/tasks.py。"""
|
||
text = str(value or "").strip()
|
||
if not text:
|
||
return None
|
||
try:
|
||
return datetime.date.fromisoformat(text)
|
||
except Exception:
|
||
pass
|
||
matched = re.search(r"(\d{4})\D+(\d{1,2})\D+(\d{1,2})", text)
|
||
if not matched:
|
||
return None
|
||
try:
|
||
return datetime.date(
|
||
int(matched.group(1)),
|
||
int(matched.group(2)),
|
||
int(matched.group(3)),
|
||
)
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
_RELATIVE_DAY_NAMES = {0: "今天", 1: "明天", 2: "后天", 3: "大后天"}
|
||
|
||
|
||
def date_match_labels(
|
||
date_value: str,
|
||
os_state: dict | None = None,
|
||
) -> list[str]:
|
||
"""Generate all plausible textual representations of a date for fuzzy matching.
|
||
|
||
Returns labels in order: ISO, M月D日, M月D号, D日, D号, 周X, 星期X,
|
||
plus relative labels (今天/明天/后天/大后天/这周X/下周X) when *os_state* is provided.
|
||
"""
|
||
parsed = parse_date(date_value)
|
||
if parsed is None:
|
||
return [str(date_value)]
|
||
|
||
wd_zh = _WEEKDAY_ZH[parsed.weekday()]
|
||
labels = [
|
||
parsed.isoformat(),
|
||
f"{parsed.month}月{parsed.day}日",
|
||
f"{parsed.month}月{parsed.day}号",
|
||
f"{parsed.day}日",
|
||
f"{parsed.day}号",
|
||
f"周{wd_zh}",
|
||
f"星期{wd_zh}",
|
||
]
|
||
|
||
if os_state is not None:
|
||
try:
|
||
today = sim_today(os_state)
|
||
delta = (parsed - today).days
|
||
rel = _RELATIVE_DAY_NAMES.get(delta)
|
||
if rel is not None:
|
||
labels.append(rel)
|
||
# 这周X / 下周X（与 format_date_natural 逻辑对齐）
|
||
if delta > 0:
|
||
today_wd = today.weekday()
|
||
if delta <= (6 - today_wd):
|
||
labels.append(f"这周{wd_zh}")
|
||
else:
|
||
days_to_next_monday = 7 - today_wd
|
||
if days_to_next_monday <= delta <= days_to_next_monday + 6:
|
||
labels.append(f"下周{wd_zh}")
|
||
except ValueError:
|
||
pass
|
||
|
||
return labels
|
||
|
||
|
||
def format_fixed(value: float, decimal_places: int) -> str:
|
||
"""统一自 crossapp3/tasks.py。"""
|
||
decimal_places = max(0, min(10, int(decimal_places)))
|
||
return f"{value:.{decimal_places}f}"
|
||
|
||
|
||
def extract_urls(text: str) -> list[str]:
|
||
"""统一自 crossapp3/tasks.py。"""
|
||
return [
|
||
url.strip().rstrip(").,，。")
|
||
for url in re.findall(r"https?://\S+", text or "")
|
||
]
|
||
|
||
|
||
def basename(path: Any) -> str:
|
||
"""统一自 crossapp3/tasks.py。"""
|
||
text = str(path or "").strip()
|
||
if not text:
|
||
return ""
|
||
text = text.split("?", 1)[0].split("#", 1)[0].replace("\\", "/")
|
||
return text.rsplit("/", 1)[-1]
|
||
|
||
|
||
def strip_postal_suffix(text: str) -> str:
|
||
"""统一自 crossapp/tasks.py、crossapp2/tasks.py。"""
|
||
raw = str(text or "").strip()
|
||
matched = re.search(r"(邮政编码|邮编)\s*[:：]?", raw)
|
||
if matched:
|
||
raw = raw[: matched.start()].strip()
|
||
# Strip Plus Code suffix (e.g. "275X+67P", "W9CW+7PQ")
|
||
raw = re.sub(r"\s*[A-Z0-9]{2,6}\+[A-Z0-9]{2,4}\s*$", "", raw)
|
||
return raw
|
||
|
||
|
||
def parse_hhmm(value: str) -> int | None:
|
||
"""统一自 spe_tasks/tasks.py。"""
|
||
matched = re.fullmatch(r"(\d{1,2}):(\d{2})", str(value or "").strip())
|
||
if not matched:
|
||
return None
|
||
hour = int(matched.group(1))
|
||
minute = int(matched.group(2))
|
||
if not (0 <= hour <= 23 and 0 <= minute <= 59):
|
||
return None
|
||
return hour * 60 + minute
|
||
|
||
|
||
def format_hhmm(hour: int, minute: int) -> str:
|
||
"""格式化小时和分钟为 HH:MM 字符串。"""
|
||
return f"{int(hour):02d}:{int(minute):02d}"
|
||
|
||
|
||
def new_items_by_id(
|
||
current: list[dict[str, Any]], initial: list[dict[str, Any]]
|
||
) -> list[dict[str, Any]]:
|
||
"""统一自 spe_tasks/tasks.py。"""
|
||
initial_ids = {str((item or {}).get("id", "")) for item in (initial or [])}
|
||
result: list[dict[str, Any]] = []
|
||
for item in current or []:
|
||
item_id = str((item or {}).get("id", ""))
|
||
if item_id and item_id not in initial_ids:
|
||
result.append(item)
|
||
result.sort(key=lambda item: int((item or {}).get("timestamp", 0) or 0))
|
||
return result
|
||
|
||
|
||
def numbers_contain_all(
|
||
haystack: list[float], expected: list[float], tol: float = 0.02
|
||
) -> bool:
|
||
"""统一自 spe_tasks/tasks.py。"""
|
||
for value in expected:
|
||
if not any(abs(float(item) - float(value)) <= tol for item in haystack):
|
||
return False
|
||
return True
|
||
|
||
|
||
def subsequence_contains_numbers(
|
||
numbers: list[float], expected: list[float], tol: float = 0.02
|
||
) -> bool:
|
||
"""统一自 spe_tasks/tasks.py。"""
|
||
if not expected:
|
||
return True
|
||
index = 0
|
||
for number in numbers:
|
||
if abs(float(number) - float(expected[index])) <= tol:
|
||
index += 1
|
||
if index >= len(expected):
|
||
return True
|
||
return False
|
||
|
||
|
||
def has_close_number(text: str, expected: float, tol: float = 0.01) -> bool:
|
||
"""统一自 ebay/tasks.py。"""
|
||
for number in extract_numbers(text):
|
||
if abs(number - expected) <= tol:
|
||
return True
|
||
return False
|
||
|
||
|
||
def has_int(text: str, expected: int) -> bool:
|
||
"""统一自 ebay/tasks.py。"""
|
||
ints = re.findall(r"(?<!\d)(\d+)(?!\d)", text)
|
||
return any(int(value) == expected for value in ints)
|
||
|
||
|
||
def url_content_contains(url: str, keyword: str) -> bool:
|
||
"""统一自 crossapp3/tasks.py。"""
|
||
url = str(url or "").strip()
|
||
keyword = str(keyword or "").strip()
|
||
if not url or not keyword:
|
||
return False
|
||
try:
|
||
response = requests.get(
|
||
url,
|
||
timeout=10,
|
||
headers={
|
||
"User-Agent": (
|
||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
|
||
"AppleWebKit/537.36 (KHTML, like Gecko) "
|
||
"Chrome/91.0.4472.124 Safari/537.36"
|
||
),
|
||
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
|
||
"Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
|
||
},
|
||
)
|
||
if not getattr(response, "ok", False):
|
||
return False
|
||
if response.encoding == "ISO-8859-1":
|
||
response.encoding = response.apparent_encoding
|
||
body = str(getattr(response, "text", "") or "")
|
||
return keyword in body or norm(keyword) in norm(body)
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def check_alternatives(
|
||
*check_arrays: list[dict[str, Any]],
|
||
) -> list[dict[str, Any]]:
|
||
"""多组按位置对应的 check 结果，返回第一组全通过的；都不过返回第一组。
|
||
|
||
每个数组长度相同，同一下标的元素属于同一个候选。
|
||
示例::
|
||
|
||
places = Map.resolve_places("故宫")
|
||
return check_alternatives(
|
||
[wechat.check_sent(addr(p), ...) for p in places],
|
||
[wechat.check_sent(weather(p), ...) for p in places],
|
||
)
|
||
"""
|
||
if not check_arrays:
|
||
return []
|
||
lengths = [len(arr) for arr in check_arrays]
|
||
if any(length == 0 for length in lengths):
|
||
raise ValueError("check_alternatives got empty candidate list")
|
||
if len(set(lengths)) != 1:
|
||
raise ValueError(f"check_alternatives got mismatched lengths: {lengths}")
|
||
n = lengths[0]
|
||
for i in range(n):
|
||
group = [arr[i] for arr in check_arrays]
|
||
if all(c.get("passed") for c in group):
|
||
return group
|
||
return [arr[0] for arr in check_arrays]
|