Satvik Reddy

Parvathareddy.

@router.post("/match")
async def match_jobs(
    profile: UserProfile,
    db: Session = Depends(get_db)
) -> list[JobMatch]:
    jobs = await fetch_active_jobs(db)

    # Score each job against the user profile
    matches = await asyncio.gather(*[
        score_job_match(profile, job)
        for job in jobs
    ])
    return sorted(
        matches,
        key=lambda m: m.score,
        reverse=True
    )

async def evaluate_response(
    model_output: str,
    expected: str,
) -> EvalScores:
    result = await openai.chat.completions.create(
        model="gpt-4o",
        response_format={"type": "json_object"},
        messages=[
            {"role": "system", "content": JUDGE_PROMPT},
            {"role": "user", "content": build_prompt(
                model_output, expected
            )},
        ],
    )
    data = json.loads(
        result.choices[0].message.content
    )
    return EvalScores(**data)

export async function reviewPR(
  pr: PullRequest
): Promise<Review> {
  const [diff, context] = await Promise.all([
    fetchDiff(pr.number),
    buildRepoContext(pr.baseSha, {
      maxTokens: 4000,
    }),
  ])

  const { choices } = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      { role: "system", content: REVIEW_PROMPT },
      { role: "user", content: buildPrompt(diff, context) },
    ],
  })

  return parseReview(choices[0].message.content)
}

export async function getVendorStatus(
  vendorIds: string[]
): Promise<DashboardData> {
  const [inventory, orders, alerts] = await Promise.all([
    db.query.inventory.findMany({
      where: inArray(inventory.vendorId, vendorIds),
      with: { vendor: true, product: true },
    }),
    fetchPendingOrders(vendorIds),
    checkDisruptionAlerts(vendorIds),
  ])

  return {
    stockHealth: calcStockHealth(inventory),
    reorderFlags: inventory.filter(
      i => i.qty < i.reorderPoint
    ),
    activeAlerts: alerts.filter(
      a => a.severity === "high"
    ),
  }
}