Innovate. Design. Build. Scale.

from __future__ import annotations

import asyncio
from dataclasses import dataclass
from time import perf_counter
from typing import TypedDict

class InferenceService:
    def __init__(self, concurrency: int = 2) -> None:
        self._guard = asyncio.Semaphore(concurrency)

    async def infer(self, task: InferenceTask) -> InferenceResult:
        async with self._guard:
            started = perf_counter()
            await asyncio.sleep(0)

            confidence = round(0.86 + (0.2 - task.temperature) * 0.08, 3)
            completion_tokens = min(task.max_tokens, 210)
            latency_ms = round((perf_counter() - started) * 1000 + 78.4, 2)

            return {
                "task_id": task.task_id,
                "model": task.model,
                "latency_ms": latency_ms,
                "confidence": confidence,
                "completion_tokens": completion_tokens,
            }


async def run_batch(tasks: list[InferenceTask]) -> list[InferenceResult]:
    service = InferenceService(concurrency=3)
    return await asyncio.gather(*(service.infer(task) for task in tasks))


async def main() -> None:
    tasks = [
        InferenceTask("A-104", "Summarize churn signals from Q1 tickets"),
        InferenceTask("A-105", "Generate launch FAQ from release notes", temperature=0.3),
        InferenceTask("A-106", "Classify feedback by sentiment and urgency"),
    ]

    results = await run_batch(tasks)
    for row in results:
        print(
            f"{row['task_id']} | {row['model']} | {row['latency_ms']:>6}ms | "
            f"conf={row['confidence']} | toks={row['completion_tokens']}"
        )


if __name__ == "__main__":
    asyncio.run(main())

from dataclasses import dataclass
from statistics import fmean


@dataclass(slots=True)
class EvalMetric:
    name: str
    score: float
    threshold: float

    @property
    def passed(self) -> bool:
        return self.score >= self.threshold


def summarize_eval(metrics: list[EvalMetric]) -> dict[str, object]:
    avg_score = round(fmean(item.score for item in metrics), 3)
    passed = [item.name for item in metrics if item.passed]
    failed = [item.name for item in metrics if not item.passed]

    return {
        "avg_score": avg_score,
        "pass_rate": round(len(passed) / max(len(metrics), 1), 2),
        "passed": passed,
        "failed": failed,
    }


evaluation = summarize_eval(
    [
        EvalMetric("groundedness", 0.93, 0.9),
        EvalMetric("hallucination_risk", 0.88, 0.85),
        EvalMetric("instruction_follow", 0.95, 0.9),
        EvalMetric("safety_policy", 0.97, 0.95),
    ]
)

print("model quality snapshot")
print(f"avg_score={evaluation['avg_score']}")
print(f"pass_rate={evaluation['pass_rate']}")
print(f"passed={evaluation['passed']}")
print(f"failed={evaluation['failed']}")