astrbot_plugin_imagestudio/backend/services/cost_service.py

351 行
13 KiB
Python

2026-07-06 02:34:43 +08:00
"""Usage and cost aggregation for generation outputs."""
from __future__ import annotations
import json
from datetime import datetime, timedelta, timezone
from typing import Any
from database.db_helper import Database
PriceSpec = float | int | dict[str, Any]
class CostService:
def __init__(
self,
database: Database,
*,
unit_prices: dict[str, PriceSpec] | None = None,
currency: str = "USD",
):
self.database = database
self.unit_prices = unit_prices or {}
self.currency = currency
def usage_summary(
self,
*,
profile_id: str | None = None,
workflow_id: str | None = None,
node_id: str | None = None,
provider_id: str | None = None,
days: int | None = None,
unit_prices: dict[str, PriceSpec] | None = None,
) -> dict[str, Any]:
prices = {**self.unit_prices, **(unit_prices or {})}
since = _since(days)
groups: dict[tuple[str, str, str], dict[str, Any]] = {}
for row in self._image_rows(profile_id=profile_id, workflow_id=workflow_id, node_id=node_id):
created_at = _parse_datetime(row["created_at"])
if since and created_at and created_at < since:
continue
metadata = _json_loads(row["metadata_json"])
provider = _provider_id(metadata)
if provider_id and provider != provider_id:
continue
provider_model = _provider_model(metadata)
model_route = str(row["model_route"] or "unknown")
usage = metadata.get("usage") if isinstance(metadata.get("usage"), dict) else {}
key = (provider, provider_model, model_route)
group = groups.setdefault(key, _new_group(provider, provider_model, model_route))
group["image_count"] += 1
task_key = str(row["task_id"] or row["image_id"])
group["_task_ids"].add(task_key)
# Image providers report usage for the whole request, while one
# request may persist several image rows. Keep the largest value
# observed for each task so the same request is not charged once
# per output image.
task_usage = group["_usage_by_task"].setdefault(
task_key,
{"total_tokens": 0, "input_tokens": 0, "output_tokens": 0},
)
task_usage["total_tokens"] = max(
task_usage["total_tokens"],
_usage_number(usage, "total_tokens", "total"),
)
task_usage["input_tokens"] = max(
task_usage["input_tokens"],
_usage_number(usage, "input_tokens", "prompt_tokens"),
)
task_usage["output_tokens"] = max(
task_usage["output_tokens"],
_usage_number(usage, "output_tokens", "completion_tokens"),
)
if not any((profile_id, workflow_id, node_id)):
# A style-set attempt projects its first validation case onto the
# legacy attempt row for compatibility. Bill the child cases and
# exclude that projection so the representative image is not
# counted twice.
advanced_rows = (
self._advanced_material_attempt_rows()
+ self._advanced_style_validation_case_rows()
)
for row in advanced_rows:
created_at = _parse_datetime(row["created_at"])
if since and created_at and created_at < since:
continue
provider = str(row["provider_id"] or "unknown")
if provider_id and provider != provider_id:
continue
provider_model = str(row["provider_model"] or "unknown")
model_route = str(row["model_route"] or "unknown")
usage = _json_loads(row["usage_json"])
key = (provider, provider_model, model_route)
group = groups.setdefault(key, _new_group(provider, provider_model, model_route))
if row["validation_image_uri"]:
group["image_count"] += 1
task_key = str(row["task_id"] or row["billing_id"])
group["_task_ids"].add(task_key)
task_usage = group["_usage_by_task"].setdefault(
task_key,
{"total_tokens": 0, "input_tokens": 0, "output_tokens": 0},
)
task_usage["total_tokens"] = max(
task_usage["total_tokens"],
_usage_number(usage, "total_tokens", "total"),
)
task_usage["input_tokens"] = max(
task_usage["input_tokens"],
_usage_number(usage, "input_tokens", "prompt_tokens"),
)
task_usage["output_tokens"] = max(
task_usage["output_tokens"],
_usage_number(usage, "output_tokens", "completion_tokens"),
)
2026-07-06 02:34:43 +08:00
finalized = [_finalize_group(group, prices) for group in groups.values()]
totals = {
"image_count": sum(group["image_count"] for group in finalized),
"task_count": sum(group["task_count"] for group in finalized),
"total_tokens": sum(group["total_tokens"] for group in finalized),
"input_tokens": sum(group["input_tokens"] for group in finalized),
"output_tokens": sum(group["output_tokens"] for group in finalized),
"estimated_cost": round(sum(group["estimated_cost"] for group in finalized), 6),
}
return {
"currency": self.currency,
"filters": {
"profile_id": profile_id,
"workflow_id": workflow_id,
"node_id": node_id,
"provider_id": provider_id,
"days": days,
},
"totals": totals,
"groups": sorted(
finalized,
key=lambda item: (item["provider_id"], item["provider_model"], item["model_route"]),
),
}
2026-07-06 02:40:18 +08:00
def estimate_cost(
self,
*,
provider_id: str,
provider_model: str,
model_route: str = "planned",
task_count: int = 1,
image_count: int = 1,
total_tokens: int = 0,
input_tokens: int = 0,
output_tokens: int = 0,
unit_prices: dict[str, PriceSpec] | None = None,
) -> float:
prices = {**self.unit_prices, **(unit_prices or {})}
group = {
"provider_id": provider_id,
"provider_model": provider_model,
"model_route": model_route,
"task_count": max(_int(task_count), 0),
"image_count": max(_int(image_count), 0),
"total_tokens": max(_int(total_tokens), 0),
"input_tokens": max(_int(input_tokens), 0),
"output_tokens": max(_int(output_tokens), 0),
}
return round(_estimate_cost(group, prices), 6)
2026-07-06 02:34:43 +08:00
def _image_rows(
self,
*,
profile_id: str | None,
workflow_id: str | None,
node_id: str | None,
) -> list[Any]:
placeholder = self.database._placeholder
where: list[str] = []
params: list[Any] = []
for column, value in (
("profile_id", profile_id),
("workflow_id", workflow_id),
("node_id", node_id),
):
if value:
where.append(f"{column} = {placeholder}")
params.append(value)
where_sql = f"WHERE {' AND '.join(where)}" if where else ""
conn = self.database.connect()
try:
return conn.execute(
f"""
SELECT image_id, task_id, profile_id, workflow_id, node_id,
model_route, metadata_json, created_at
FROM generation_images
{where_sql}
ORDER BY created_at DESC
""",
tuple(params),
).fetchall()
finally:
conn.close()
def _advanced_material_attempt_rows(self) -> list[Any]:
conn = self.database.connect()
try:
return conn.execute(
"""
SELECT attempt_id AS billing_id, task_id, model_route, provider_id,
provider_model, usage_json, validation_image_uri, created_at
FROM advanced_material_validation_attempts AS attempt
WHERE (usage_json IS NOT NULL OR validation_image_uri IS NOT NULL)
AND NOT EXISTS (
SELECT 1 FROM advanced_style_validation_cases AS style_case
WHERE style_case.attempt_id = attempt.attempt_id
)
ORDER BY created_at DESC
"""
).fetchall()
finally:
conn.close()
def _advanced_style_validation_case_rows(self) -> list[Any]:
conn = self.database.connect()
try:
return conn.execute(
"""
SELECT case_id AS billing_id, task_id, model_route, provider_id,
provider_model, usage_json, validation_image_uri, created_at
FROM advanced_style_validation_cases
WHERE usage_json IS NOT NULL OR validation_image_uri IS NOT NULL
ORDER BY created_at DESC
"""
).fetchall()
finally:
conn.close()
2026-07-06 02:34:43 +08:00
def _new_group(provider_id: str, provider_model: str, model_route: str) -> dict[str, Any]:
return {
"provider_id": provider_id,
"provider_model": provider_model,
"model_route": model_route,
"image_count": 0,
"task_count": 0,
"total_tokens": 0,
"input_tokens": 0,
"output_tokens": 0,
"estimated_cost": 0.0,
"_task_ids": set(),
"_usage_by_task": {},
2026-07-06 02:34:43 +08:00
}
def _finalize_group(group: dict[str, Any], prices: dict[str, PriceSpec]) -> dict[str, Any]:
group = dict(group)
group["task_count"] = len(group.pop("_task_ids"))
usage_by_task = group.pop("_usage_by_task")
group["total_tokens"] = sum(item["total_tokens"] for item in usage_by_task.values())
group["input_tokens"] = sum(item["input_tokens"] for item in usage_by_task.values())
group["output_tokens"] = sum(item["output_tokens"] for item in usage_by_task.values())
2026-07-06 02:34:43 +08:00
group["estimated_cost"] = round(_estimate_cost(group, prices), 6)
return group
def _estimate_cost(group: dict[str, Any], prices: dict[str, PriceSpec]) -> float:
spec = _price_spec(group, prices)
if spec is None:
return 0.0
if isinstance(spec, (int, float)):
return float(spec) * int(group["task_count"])
per_request = _float(spec.get("per_request"))
per_image = _float(spec.get("per_image"))
per_1k_tokens = _float(spec.get("per_1k_tokens"))
return (
per_request * int(group["task_count"])
+ per_image * int(group["image_count"])
+ per_1k_tokens * int(group["total_tokens"]) / 1000
)
def _price_spec(group: dict[str, Any], prices: dict[str, PriceSpec]) -> PriceSpec | None:
provider_id = group["provider_id"]
provider_model = group["provider_model"]
for key in (
f"{provider_id}:{provider_model}",
f"{provider_id}/{provider_model}",
provider_id,
provider_model,
):
if key in prices:
return prices[key]
return None
def _provider_id(metadata: dict[str, Any]) -> str:
provider_error = metadata.get("provider_error") if isinstance(metadata.get("provider_error"), dict) else {}
return str(metadata.get("provider_id") or provider_error.get("provider_id") or "unknown")
2026-07-06 02:34:43 +08:00
def _provider_model(metadata: dict[str, Any]) -> str:
return str(metadata.get("provider_model") or metadata.get("model") or "unknown")
def _usage_number(usage: dict[str, Any], *keys: str) -> int:
for key in keys:
value = usage.get(key)
if value is not None:
return _int(value)
if "total_tokens" in keys:
return _int(usage.get("input_tokens")) + _int(usage.get("output_tokens"))
return 0
def _since(days: int | None) -> datetime | None:
if days is None:
return None
return datetime.now(timezone.utc) - timedelta(days=max(_int(days), 0))
def _parse_datetime(value: Any) -> datetime | None:
text = str(value or "").strip()
if not text:
return None
try:
parsed = datetime.fromisoformat(text.replace("Z", "+00:00"))
except ValueError:
return None
if parsed.tzinfo is None:
parsed = parsed.replace(tzinfo=timezone.utc)
return parsed
def _json_loads(value: str | None) -> dict[str, Any]:
if not value:
return {}
parsed = json.loads(value)
return parsed if isinstance(parsed, dict) else {}
def _int(value: Any) -> int:
try:
return int(value or 0)
except (TypeError, ValueError):
return 0
def _float(value: Any) -> float:
try:
return float(value or 0)
except (TypeError, ValueError):
return 0.0