మీరు సీనియర్ [language/framework] ఇంజనీర్, [project/domain] కోసం కోడ్ సమీక్ష చేస్తున్నారు.
లక్ష్యం: [బగ్ సరి చేయడం | పనితీరు | చదవడంకి సులభత | సెక్యూరిటీ | డెవలపర్ అనుభవం | API సారూప్యత]
పరిమితులు: [శైలి గైడ్, మద్దతు పొందిన వర్షన్లు, స్మృతి/సమయం పరిమితులు, లైబ్రరీ పరిమితులు]
సందర్భం:
- రన్‌టైమ్/ఎన్‌విరాన్‌మెంట్: [Node 20, JVM 17, Python 3.11, iOS 17, మొదలయినవి]
- కీలక డిపెండెన్సీలు: [జాబితా]
- ఆర్కిటెక్చర్: [మోనోలిథ్, మైక్రోసర్వీస్, సర్వర్‌లెస్, హెక్సాగనల్, మొదలయినవి]
- సంబంధిత ఇంటర్‌ఫేసులు/కాంట్రాక్టులు: [లింక్ లేదా ఇన్‌లైన్]
పని:
1) ఈ క్రింద ఉన్న కోడ్‌ను [లక్ష్యాలు] కోసం సమీక్షించండి.
2) సంభవ సమస్యలను సాక్ష్యాలతో గుర్తించండి (లైన్ సూచనలు, సంక్లిష్టత అంచనాలు, ఎడ్జ్ కేసులు).
3) కనిష్టం, లక్ష్యభరితమైన డిఫ్స్‌ని సూచించండి.
4) తుది పునఃరూపకృత కవర్ ఇవ్వండి.
5) ట్రేడ్అఫ్స్ మరియు ప్రమాదాలను వివరించండి.
కోడ్:
```[language]
// ఇక్కడ కోడ్ పేస్ట్ చేయండి

లక్ష్యం: ప్రజాస్వామ్య ప్రవర్తన మార్చకుండా సమయం మరియు స్మృతి సంక్లిష్టత తగ్గించడం.
చెప్పండి: ప్రస్తుత సంక్లిష్టత, ప్రతిపాదిత సంక్లిష్టత, సూక్ష్మ ఆప్టిమైజేషన్‌లు మరియు అల్గారిథమిక్ మార్పులు, మరియు నడిపించాల్సిన బెంచ్‌మార్క్లు.

స్పష్టత కోసం పునఃరూపకరణ: మెరుగైన పేర్లివ్వటం, చిన్న ఫంక్షన్లు, ఏక సామర్థ్యం.
డాక్స్‌ట్రింగ్స్/JSdoc జోడించండి, నియంత్రణ ప్రవాహం సులభతరం చేయండి, మరణించిన కోడ్ తీసివేయండి. పబ్లిక్ API స్థిరంగా ఉంచండి.

భయభీత మోడల్: [మూలం] నుండి అప్రమాణితం ఇన్‌పుట్.
పరీక్షించండి: ఇంజెక్షన్, డీ-సీరియలైజేషన్, SSRF, XSS, CSRF, authZ/authN, సీక్రెట్స్ నిర్వహణ.
సూచించండి: సురక్షిత లైబ్రరీలు, వాలిడేషన్ నమూనాలు, మరియు కనిష్ట డిఫ్స్.

మేము [లైబ్ A] నుండి [లైబ్ B] కి మారుతున్నాము.
భంగమైన మార్పులను జాబితా చేయండి, అడాప్టర్ లేయర్‌ను ప్రతిపాదించండి, మరియు పరీక్షలతో అనుక్రమ రోల్‌అవుట్ ప్లాన్ అందించండి.

ఎన్‌విరాన్‌మెంట్: Python 3.11, FastAPI, Pydantic v2.
కాంట్రాక్ట్: ఎండ్‌పాయింట్ 200 రిటర్న్ చేయాలి { data, meta }తో భాగస్వామ్య విఫలాలపై కూడా.
పరిమితి: అసింక్రనస్‌గా ఉండాలి; పలు భారమైన ఆధారాలు జోడించకూడదు.

1) విమర్శ: సాక్ష్యాలతో కాంక్రీట్ సమస్యలను జాబితా చేయండి.
2) డిఫ్: పరిష్కరించడానికి కనిష్ట మార్పులు.
3) పునఃరూపకరణ: శుభ్రమైన, సామాన్యమైన తుది కోడ్.
4) పరీక్షలు: హ్యాపీ పాత్ + 3 ఎడ్జ్ కేసుల యూనిట్ పరీక్షలు.

3 పునఃరూపకరణ ఎంపికలను ప్రతిపాదించండి:
- ఎంపిక A: కనిష్ట మార్పు
- ఎంపిక B: మధ్యస్థ రీడిజైన్
- ఎంపిక C: సంపూర్ణ రిరైటింగ్
ప్రతి ఒక్కదానికి: మేలు/తీవ్రతలు, సంక్లిష్టత, ప్రమాదం, మైగ్రేషన్ ప్లాన్, ఎప్పుడు ఎంచుకోవాలి.

పరిమితులు: అదే పబ్లిక్ API, p95 < 50ms, అదనపు 10MB కన్నా తక్కువ స్మృతి, కొత్త రన్‌టైమ్ ఆధారాలు ఉండకూడదు.
మీ పునఃరూపకరణ ప్రతి పరిమితిని కొలతలు లేదా తర్కంతో ఎలా తీర్చిందో చూపండి.

మీరు సీనియర్ Python ఇంజనీర్. లక్ష్యం: సరైన పనితీరు.
ఎన్‌వి: Python 3.11, FastAPI, httpx, Pydantic v2. కాంట్రాక్ట్: భాగస్వామ్య విఫలంపై ఎప్పుడూ ఎర్రర్ రాకూడదు.
పని: సమీక్షించండి మరియు పునఃరూపకరం చేయండి. విమర్శ → కనిష్ట డిఫ్స్ → తుది పునఃరూపకరణ → పరీక్షలు ఇవ్వండి.
కోడ్:
```python
from fastapi import APIRouter
import httpx
router = APIRouter()
@router.get("/users/{user_id}")
async def get_user(user_id: str):
    async with httpx.AsyncClient() as client:
        profile = await client.get(f")
        posts = await client.get(f")
    return {"data": {"profile": profile.json(), "posts": posts.json()}}

ప్రతి సూచనను {తీవ్రత, వర్గం, కారణం}తో గుర్తించి, ముందు/తర్వాత ఉదాహరణలతో మరియు మార్పు సంభావన ఉంటే ఒక్క దశ మైగ్రేషన్ ప్లానుతో జోడించండి.

ఈ రిపో రూట్ నుండి సరైన ఫైల్ పథాలతో యూనిఫైడ్ డిఫ్ రూపంలో అవుట్పుట్ ఇవ్వండి. మార్చబడిన హుంక్‌లను మాత్రమే కలుపుకోండి. డిఫ్ లో వ్యాఖ్యలు ఉండవద్దు. తరువాత గమనికల కోసం ప్రత్యేక విభాగం చేర్పండి.

నిజంగా రెండు బ్లాక్‌లతో స్పందించండి:
1) ```diff
...మార్పులు...

ప్రతి మార్పును ఒక వాక్యంలో, లైన్ లేదా కోడ్ స్నిపెట్ ను సూచిస్తూ వివరించండి. అనిశ్చితి ఉంటే, ఊహించడం కాకుండా స్పష్టీకరణ ప్రశ్న అడగండి.

ఆవশ্যకంగా ఉంటే 3 లోపు స్పష్టీకరణ ప్రశ్నలు అడగగలరు.

పాత్ర: సీనియర్ TypeScript ఇంజనీర్.
లక్ష్యం: పబ్లిక్ API మార్చకుండా చదవగలిగే రీతిని మరియు రన్‌టైమ్ సేఫ్టీని మెరుగుపరచడం.
ఎన్‌వి: Node 20, TypeScript 5.4, Zod వాలిడేషన్ కోసం, ESLint Airbnb, strictNullChecks.
పరిమితులు: కొత్త రన్‌టైమ్ ఆధారాలు Zod కన్నా ఎక్కువ లేకుండా, విరమించని మార్పులు వుండకూడదు, O(n) సంక్లిష్టత ఉంచాలి.
పని:
- విమర్శ → డిఫ్ → పునఃరూపకరణ → పరీక్షలు → గమనికలు.
- {తీవ్రత, వర్గం, కారణం}తో సమస్యలను గుర్తించండి.
- ఇన్‌పుట్ వాలిడేషన్ కోసం Zod స్కీమను చేర్చండి మరియు 4 యూనిట్ పరీక్షలు ఇవ్వండి.
కోడ్:
```ts
export function parseUser(raw: any) {
  if (!raw) return null;
  return {
    id: raw.id || '0',
    name: raw.name || 'Unknown',
    age: parseInt(raw.age),
  };
}

మానసిక ESLint పాస్ చేయండి, ఎదురు చూడబోయే ఉల్లంఘనలు జాబితా చేయండి, తరువాత వాటిని సరి చేయండి.

ప్రతి మార్పుకు refactoring నమూనా పేరు (ఉదా: ఫంక్షన్‌ను తీసివేయడం, పారామీటర్ ఆబ్జెక్ట్ పరిచయం) చెప్పండి, మరియు ఈ కోడ్లో దాన్ని ఎప్పుడు ఉపయోగించాలో వివరించండి.

కేవలం రిపోజ్ సందర్భాన్ని ఉపయోగించండి. ఈ PR లో మార్చిన ఫైళ్లను [లక్ష్యం] కోసం సమీక్షించండి. inline గా తీవ్రత మరియు కారణంతో ఉల్లేఖనాలు ఇవ్వండి. పబ్లిక్ API మరియు NFRలను రక్షించే డిఫ్స్ ప్రతిపాదించండి. మార్చిన మార్గాలను మాత్రమే పరీక్షలతో కవర్ చేయండి.