173 行
8.8 KiB
Python
173 行
8.8 KiB
Python
"""Aggregate material composition and prompt-governance adoption metrics."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from collections import Counter
|
|
from typing import Any
|
|
|
|
from database.db_helper import Database
|
|
|
|
|
|
class MaterialAnalyticsService:
|
|
def __init__(self, database: Database):
|
|
self.database = database
|
|
|
|
def summarize(self) -> dict[str, Any]:
|
|
conn = self.database.connect()
|
|
try:
|
|
materials = conn.execute("SELECT recognition_status, metadata_json FROM materials WHERE recognition_status != 'archived'").fetchall()
|
|
advanced_materials = conn.execute(
|
|
"""
|
|
SELECT material.status, material.metadata_json, attempt.fidelity_score
|
|
FROM advanced_materials AS material
|
|
LEFT JOIN advanced_material_validation_attempts AS attempt
|
|
ON attempt.attempt_id = material.accepted_attempt_id
|
|
WHERE material.status != 'archived'
|
|
"""
|
|
).fetchall()
|
|
advanced_attempts = conn.execute(
|
|
"SELECT status, fidelity_score FROM advanced_material_validation_attempts"
|
|
).fetchall()
|
|
style_imports = conn.execute(
|
|
"SELECT status, metadata_json FROM advanced_material_imports"
|
|
).fetchall()
|
|
style_sources = conn.execute(
|
|
"SELECT status FROM advanced_style_sources"
|
|
).fetchall()
|
|
style_consensus_runs = conn.execute(
|
|
"SELECT status FROM advanced_style_consensus_runs"
|
|
).fetchall()
|
|
style_validation_cases = conn.execute(
|
|
"SELECT status, fidelity_score FROM advanced_style_validation_cases"
|
|
).fetchall()
|
|
audits = conn.execute("SELECT action, after_snapshot, metadata_json FROM audit_logs WHERE action IN ('wardrobe_match','apply_wardrobe_template','recognize_material','renormalize_material')").fetchall()
|
|
tasks = conn.execute("SELECT model_route, request_json, metadata_json FROM generation_tasks").fetchall()
|
|
finally:
|
|
conn.close()
|
|
schema_count = 0
|
|
confirmed_count = 0
|
|
category_counts: Counter[str] = Counter()
|
|
needs_confirmation = 0
|
|
for row in materials:
|
|
metadata = _json(row["metadata_json"])
|
|
profile = metadata.get("normalized_asset_profile") if isinstance(metadata.get("normalized_asset_profile"), dict) else {}
|
|
if profile:
|
|
schema_count += 1
|
|
category_counts[str(profile.get("category") or "other")] += 1
|
|
needs_confirmation += int(bool(profile.get("requires_confirmation")))
|
|
confirmed_count += int(str(row["recognition_status"]) == "confirmed")
|
|
composition_count = conflicts = ignored = downgraded = 0
|
|
for row in audits:
|
|
snapshot = _json(row["after_snapshot"])
|
|
composition = snapshot.get("composition") if isinstance(snapshot.get("composition"), dict) else snapshot.get("composition_result") if isinstance(snapshot.get("composition_result"), dict) else {}
|
|
if not composition and row["action"] == "wardrobe_match":
|
|
composition = snapshot.get("composition") if isinstance(snapshot.get("composition"), dict) else {}
|
|
if composition:
|
|
composition_count += 1
|
|
conflicts += len(composition.get("conflicts") or [])
|
|
ignored += len(composition.get("ignored_materials") or [])
|
|
downgraded += len(composition.get("downgraded_materials") or [])
|
|
translation_status: Counter[str] = Counter()
|
|
moderation_levels: Counter[str] = Counter()
|
|
route_reasons: Counter[str] = Counter()
|
|
route_counts: Counter[str] = Counter()
|
|
for row in tasks:
|
|
request = _json(row["request_json"])
|
|
governance = request.get("prompt_governance") if isinstance(request.get("prompt_governance"), dict) else {}
|
|
translation = governance.get("translation") if isinstance(governance.get("translation"), dict) else {}
|
|
moderation = governance.get("moderation") if isinstance(governance.get("moderation"), dict) else {}
|
|
route = governance.get("route_decision") if isinstance(governance.get("route_decision"), dict) else {}
|
|
if translation:
|
|
translation_status[str(translation.get("status") or "unknown")] += 1
|
|
if moderation:
|
|
moderation_levels[str(moderation.get("level") or "unknown")] += 1
|
|
if route:
|
|
route_reasons[str(route.get("reason") or "unknown")] += 1
|
|
route_counts[str(row["model_route"] or route.get("selected_route") or "unresolved")] += 1
|
|
total = len(materials)
|
|
accepted_advanced = sum(1 for row in advanced_materials if str(row["status"]) == "active")
|
|
active_style_sets = sum(
|
|
1
|
|
for row in advanced_materials
|
|
if str(row["status"]) == "active" and _is_style_set_metadata(_json(row["metadata_json"]))
|
|
)
|
|
style_set_import_rows = [
|
|
row for row in style_imports if _is_style_set_metadata(_json(row["metadata_json"]))
|
|
]
|
|
style_source_statuses = Counter(str(row["status"] or "unknown") for row in style_sources)
|
|
style_consensus_statuses = Counter(str(row["status"] or "unknown") for row in style_consensus_runs)
|
|
style_case_statuses = Counter(str(row["status"] or "unknown") for row in style_validation_cases)
|
|
style_case_scores = [
|
|
float(row["fidelity_score"])
|
|
for row in style_validation_cases
|
|
if row["fidelity_score"] is not None
|
|
]
|
|
reviewed_attempts = [row for row in advanced_attempts if str(row["status"]) in {"accepted", "rejected"}]
|
|
accepted_attempts = sum(1 for row in reviewed_attempts if str(row["status"]) == "accepted")
|
|
scored_attempts = [float(row["fidelity_score"]) for row in reviewed_attempts if row["fidelity_score"] is not None]
|
|
return {
|
|
"materials": {
|
|
"total": total,
|
|
"confirmed": confirmed_count,
|
|
"schema_adoption_count": schema_count,
|
|
"schema_adoption_rate": round(schema_count / total, 4) if total else 0.0,
|
|
"needs_confirmation": needs_confirmation,
|
|
"categories": dict(category_counts),
|
|
},
|
|
"advanced_materials": {
|
|
"active": accepted_advanced,
|
|
"active_style_sets": active_style_sets,
|
|
"validation_attempts": len(advanced_attempts),
|
|
"reviewed_attempts": len(reviewed_attempts),
|
|
"acceptance_rate": round(accepted_attempts / len(reviewed_attempts), 4) if reviewed_attempts else 0.0,
|
|
"average_fidelity_score": round(sum(scored_attempts) / len(scored_attempts), 4) if scored_attempts else None,
|
|
},
|
|
"advanced_style_sets": {
|
|
"imports": len(style_set_import_rows),
|
|
"accepted_imports": sum(1 for row in style_set_import_rows if str(row["status"]) == "accepted"),
|
|
"active_materials": active_style_sets,
|
|
"sources": len(style_sources),
|
|
"source_statuses": dict(style_source_statuses),
|
|
"consensus_runs": len(style_consensus_runs),
|
|
"consensus_statuses": dict(style_consensus_statuses),
|
|
"validation_cases": len(style_validation_cases),
|
|
"validation_case_statuses": dict(style_case_statuses),
|
|
"average_case_fidelity_score": (
|
|
round(sum(style_case_scores) / len(style_case_scores), 4)
|
|
if style_case_scores
|
|
else None
|
|
),
|
|
},
|
|
"composition": {
|
|
"runs": composition_count,
|
|
"conflicts": conflicts,
|
|
"ignored_materials": ignored,
|
|
"downgraded_materials": downgraded,
|
|
"conflict_rate": round(conflicts / composition_count, 4) if composition_count else 0.0,
|
|
},
|
|
"prompt_governance": {
|
|
"translation_status": dict(translation_status),
|
|
"moderation_levels": dict(moderation_levels),
|
|
"route_reasons": dict(route_reasons),
|
|
"route_distribution": dict(route_counts),
|
|
},
|
|
}
|
|
|
|
|
|
def _json(value: Any) -> dict[str, Any]:
|
|
if isinstance(value, dict):
|
|
return value
|
|
try:
|
|
parsed = json.loads(value or "{}")
|
|
except (TypeError, json.JSONDecodeError):
|
|
return {}
|
|
return parsed if isinstance(parsed, dict) else {}
|
|
|
|
|
|
def _is_style_set_metadata(metadata: dict[str, Any]) -> bool:
|
|
return (
|
|
str(metadata.get("workflow_kind") or "").strip().casefold() == "style_set"
|
|
or isinstance(metadata.get("style_set"), dict)
|
|
or metadata.get("style_set") is True
|
|
)
|