Skip to content

PRINTFILM: AI short-video marketing and AI short-drama creation platform

11.4 KB
Raw Blame
"""TokenFree / New API 计价表达式求值。

任务表达式(含 u())的结果是美元;token 表达式的系数是美元/百万 tokens。
分组倍率取 1。结算若对上消费日志,以日志 quota 覆盖这里的结果。
"""

from __future__ import annotations

import logging
import math
from typing import Any

from app.config import Settings, get_settings
from app.services.tokenfree_usage import usd_cny_rate

logger = logging.getLogger(__name__)

_TOKEN_VARS = ("p", "c", "len", "cr", "cc", "cc1h", "img", "ai", "ao")


def usd_to_charge_fen(usd: float, settings: Settings | None = None) -> int:
    """美元按 New API quota(500000 = 1 USD)折人民币分。"""
    try:
        amount = float(usd)
    except (TypeError, ValueError):
        return 0
    if amount <= 0:
        return 0
    fen = amount * usd_cny_rate(settings) * 100
    snapped = round(fen, 6)
    if snapped <= 0:
        return 0
    return max(1, int(math.ceil(snapped - 1e-9)))


def expression_usd(expr: str, *, tokens: dict[str, float], usage: dict[str, Any]) -> float | None:
    """求值 billing_expr,返回本单美元。语法错误或事实不足时返回 None。"""
    text = (expr or "").split("|||", 1)[0].strip()
    if not text:
        return None
    if _missing_task_fact(text, usage):
        return None
    env = {name: float(tokens.get(name) or 0) for name in _TOKEN_VARS}
    env["__usage__"] = usage
    try:
        value = float(_Parser(text, env).parse())
    except (ValueError, TypeError, ZeroDivisionError) as exc:
        logger.info("billing expr 求值失败: %s", exc)
        return None
    if not math.isfinite(value) or value < 0:
        return None
    if _is_task_expr(text):
        return value
    return value / 1_000_000.0


def quote_verified_charge_fen(
    *,
    model: str,
    prompt: int = 0,
    completion: int = 0,
    total: int = 0,
    usage: dict[str, Any] | None = None,
    settings: Settings | None = None,
) -> int | None:
    """按已缓存的 TokenFree 价目报价(分)。没有可核实规则时返回 None。"""
    from app.services.tokenfree_pricing import canonicalize_channel_model_id, lookup_rate

    rate = lookup_rate(model)
    if rate is None:
        mapped = canonicalize_channel_model_id(model)
        if mapped and mapped != (model or "").strip():
            rate = lookup_rate(mapped)
    if rate is None:
        return None
    facts = dict(usage) if isinstance(usage, dict) else {}
    s = settings or get_settings()
    # Seedance 等任务表达式读 u("tokens");调用方只传 total 时补进 usage
    if (not facts.get("tokens") or float(facts.get("tokens") or 0) <= 0) and int(total or 0) > 0:
        facts["tokens"] = int(total)
    if rate.billing_mode == "tiered_expr" and rate.billing_expr:
        usd = expression_usd(
            rate.billing_expr,
            tokens={
                "p": float(prompt or 0),
                "c": float(completion or 0),
                "len": float(prompt or total or 0),
            },
            usage=facts,
        )
        if usd is None or usd <= 0:
            return None
        fen = usd_to_charge_fen(usd, s)
        return fen if fen > 0 else None
    if rate.billing == "per_call" and rate.usd_per_call > 0:
        count = _positive_count(facts.get("image_count") or facts.get("results") or 1)
        fen = usd_to_charge_fen(rate.usd_per_call * count, s)
        return fen if fen > 0 else None
    if rate.billing == "token" and not rate.placeholder and (rate.cny_in_per_1m or rate.cny_out_per_1m):
        prompt_n, completion_n = int(prompt or 0), int(completion or 0)
        if prompt_n + completion_n <= 0 and int(total or 0) > 0:
            prompt_n = int(int(total) * 0.7)
            completion_n = int(total) - prompt_n
        if prompt_n + completion_n <= 0:
            return None
        yuan = (
            prompt_n / 1_000_000 * rate.cny_in_per_1m
            + completion_n / 1_000_000 * rate.cny_out_per_1m
        )
        if yuan <= 0:
            return None
        return max(1, int(math.ceil(round(yuan * 100, 6))))
    return None


def _is_task_expr(expr: str) -> bool:
    """含 u() 的是任务用量表达式,结果已经是美元。"""
    return 'u("' in expr or "u('" in expr


def _missing_task_fact(expr: str, usage: dict[str, Any]) -> bool:
    """秒价 / 字符价缺少对应事实时不要当成 0 美元。"""
    if 'u("seconds")' in expr or "u('seconds')" in expr:
        if float(usage.get("seconds") or 0) <= 0:
            return True
    if 'u("audio_characters")' in expr or "u('audio_characters')" in expr:
        if float(usage.get("audio_characters") or 0) <= 0:
            return True
    return False


def _positive_count(value: Any) -> int:
    try:
        count = int(float(value))
    except (TypeError, ValueError):
        return 1
    return count if count > 0 else 1


def _truthy(value: Any) -> bool:
    if isinstance(value, str):
        return bool(value)
    if isinstance(value, bool):
        return value
    try:
        return float(value) != 0.0
    except (TypeError, ValueError):
        return bool(value)


def _cmp(op: str, left: Any, right: Any) -> bool:
    if op in {"==", "!="}:
        same = left == right
        if not same:
            try:
                same = float(left) == float(right)
            except (TypeError, ValueError):
                same = False
        return same if op == "==" else not same
    try:
        lf, rf = float(left), float(right)
    except (TypeError, ValueError):
        return False
    if op == "<":
        return lf < rf
    if op == "<=":
        return lf <= rf
    if op == ">":
        return lf > rf
    if op == ">=":
        return lf >= rf
    raise ValueError(f"未知比较 {op}")


class _Parser:
    """只支持价目里出现的三元表达式、比较、四则和 u/tier/fixed。"""

    def __init__(self, src: str, env: dict[str, Any]) -> None:
        self.src = src
        self.n = len(src)
        self.i = 0
        self.env = env

    def parse(self) -> Any:
        value = self._ternary()
        self._skip()
        if self.i < self.n:
            raise ValueError(f"表达式未解析完: {self.src[self.i:self.i + 24]}")
        return value

    def _skip(self) -> None:
        while self.i < self.n and self.src[self.i] in " \t\r\n":
            self.i += 1

    def _starts(self, token: str) -> bool:
        self._skip()
        return self.src.startswith(token, self.i)

    def _eat(self, token: str) -> bool:
        if self._starts(token):
            self.i += len(token)
            return True
        return False

    def _ternary(self) -> Any:
        cond = self._or()
        if self._eat("?"):
            yes = self._ternary()
            if not self._eat(":"):
                raise ValueError("三元表达式缺少 :")
            no = self._ternary()
            return yes if _truthy(cond) else no
        return cond

    def _or(self) -> Any:
        value = self._and()
        while self._eat("||"):
            right = self._and()
            value = _truthy(value) or _truthy(right)
        return value

    def _and(self) -> Any:
        value = self._cmp_expr()
        while self._eat("&&"):
            right = self._cmp_expr()
            value = _truthy(value) and _truthy(right)
        return value

    def _cmp_expr(self) -> Any:
        value = self._add()
        for op in ("==", "!=", "<=", ">=", "<", ">"):
            if self._eat(op):
                return _cmp(op, value, self._add())
        return value

    def _add(self) -> Any:
        value = self._mul()
        if not (self._starts("+") or self._starts("-")):
            return value
        value = float(value)
        while True:
            if self._eat("+"):
                value += float(self._mul())
            elif self._eat("-"):
                value -= float(self._mul())
            else:
                return value

    def _mul(self) -> Any:
        value = self._unary()
        if not (self._starts("*") or self._starts("/")):
            return value
        value = float(value)
        while True:
            if self._eat("*"):
                value *= float(self._unary())
            elif self._eat("/"):
                denom = float(self._unary())
                if denom == 0:
                    raise ZeroDivisionError("除数为 0")
                value /= denom
            else:
                return value

    def _unary(self) -> Any:
        if self._eat("-"):
            return -float(self._primary())
        return self._primary()

    def _primary(self) -> Any:
        self._skip()
        if self.i >= self.n:
            raise ValueError("表达式意外结束")
        ch = self.src[self.i]
        if ch == "(":
            self.i += 1
            value = self._ternary()
            if not self._eat(")"):
                raise ValueError("缺少 )")
            return value
        if ch == '"':
            return self._string()
        if ch.isdigit() or ch == ".":
            return self._number()
        name = self._ident()
        if self._eat("("):
            args: list[Any] = []
            if not self._eat(")"):
                while True:
                    args.append(self._ternary())
                    if self._eat(")"):
                        break
                    if not self._eat(","):
                        raise ValueError("函数参数缺少 ,")
            return self._call(name, args)
        if name in self.env and name != "__usage__":
            return self.env[name]
        raise ValueError(f"未知标识 {name}")

    def _string(self) -> str:
        self.i += 1
        chars: list[str] = []
        while self.i < self.n:
            ch = self.src[self.i]
            self.i += 1
            if ch == '"':
                return "".join(chars)
            if ch == "\\" and self.i < self.n:
                chars.append(self.src[self.i])
                self.i += 1
                continue
            chars.append(ch)
        raise ValueError("字符串未闭合")

    def _number(self) -> float:
        start = self.i
        while self.i < self.n and (self.src[self.i].isdigit() or self.src[self.i] == "."):
            self.i += 1
        try:
            return float(self.src[start:self.i])
        except ValueError as exc:
            raise ValueError(f"非法数字 {self.src[start:self.i]}") from exc

    def _ident(self) -> str:
        self._skip()
        start = self.i
        while self.i < self.n and (self.src[self.i].isalnum() or self.src[self.i] == "_"):
            self.i += 1
        if start == self.i:
            raise ValueError(f"无法解析 {self.src[self.i:self.i + 12]!r}")
        return self.src[start:self.i]

    def _call(self, name: str, args: list[Any]) -> Any:
        if name == "u":
            if len(args) != 1:
                raise ValueError("u() 需要一个参数")
            usage = self.env.get("__usage__")
            if not isinstance(usage, dict):
                return 0
            value = usage.get(str(args[0]), 0)
            return 0 if value is None else value
        if name == "tier":
            if len(args) != 2:
                raise ValueError("tier() 需要两个参数")
            return args[1]
        if name == "fixed":
            if len(args) != 1:
                raise ValueError("fixed() 需要一个参数")
            return float(args[0]) * 1_000_000.0
        if name in {"max", "min"} and len(args) == 2:
            nums = (float(args[0]), float(args[1]))
            return max(nums) if name == "max" else min(nums)
        raise ValueError(f"不支持的函数 {name}")