તમે સિનિયર [ભાષા/ફ્રેમવર્ક] એન્જિનિયર છો જે [પ્રોજેક્ટ/વિભાગ] માટે કોડ સમીક્ષા કરી રહ્યા છો.
ઉદ્દેશ્ય: [બગ ફિક્સ | પ્રદર્શન | વાંચનીયતા | સલામતી | ડિવેલપર અનુભવ | API સમરસતા]
બંધારણો: [શૈલી માર્ગદર્શિકા, સમર્થિત વર્ઝન, મેમરી/સમય મર્યાદા, લાઇબ્રેરી નિયંત્રણ]
પરિસ્થિતિ:
- રનટાઈમ/પર્યાવરણ: [Node 20, JVM 17, Python 3.11, iOS 17, વગેરે]
- મુખ્ય નિર્ભરતા: [યાદી]
- આર્કિટેક્ચર: [મોનોલિથ, માઇક્રોસર્વિસ, સર્વરલેસ, હેક્સાગોનલ, વગેરે]
- સંબંધિત ઈન્ટરફેસ/કોન્ટ્રેક્ટ: [લિંક અથવા ઈનલાઇન]
કાર્ય:
1) નીચે આપેલો કોડ [લક્ષ્યો] માટે સમીક્ષા કરો.
2) સબૂત સાથે ચોક્કસ સમસ્યાઓ ઓળખો (લાઇન સંદર્ભ, જટિલતાના અંદાજપત્ર, કેજ કેસ).
3) ઓછામાં ઓછી અને લક્ષ્યાંકિત ફેરફારો સૂચવો.
4) અંતિમ રિફેક્ટર કરેલ સંસ્કરણ આપો.
5) ટ્રેડ-ઓફ્સ અને જોખમો સમજાવો.
કોડ:
```[ભાષા]
// આ સ્થળે કોડ પેસ્ટ કરો

ઉદ્દેશ્ય: જાહેર વર્તન બદલ્યા વિના સમય અને મેમરી જટિલતા ઘટાડવી.
આઉટપુટમાં વર્તમાન જટિલતા, પ્રસ્તાવિત જટિલતા, માઇક્રો-ઓપ્ટિમાઈઝેશન્સ અને અલ્ગોરિધમિક ફેરફારો, તેમજ ચલાવવાની বেঞ্চમાર્ક્સ સમાવિષ્ટ કરો.

સ્પષ્ટતા માટે રિફેક્ટર કરો: વધુ સારી નામકરણ, નાની ફંક્શન્સ, એકજ જવાબદારી.
ડોકસ્ટ્રિંગ્સ/JSDoc ઉમેરો, કંટ્રોલ ફ્લો સરળ બનાવો, જાણીતા અપ્રયોગી કોડ દૂર કરો. જાહેર API સ્થિર રાખો.

ધમકી મોડેલ: અવિશ્વસનીય ઇનપુટ સૂત્ર [સ્ત્રોત].
પરીક્ષણ કરો: ઇન્જેક્શન, ડીસિરિયલાઇઝેશન, SSRF, XSS, CSRF, ઑથોરાઇઝેશન/ઑથેન્ટિકેશન, સિક્રેટ્સ હેન્ડલિંગ.
સૂચવો: સલામત લાઇબ્રેરીઝ, વેલિડેશન પેટર્ન અને ન્યૂનતમ ડિફ્સ.

અમે [લાઇબ A]થી [લાઇબ B]માં માઇગ્રેટ થઈ રહ્યા છે.
વિગતવાર તૂટવાના ફેરફારો સૂચવો, એડેપ્ટર લેયર પ્રસ્તાવિત કરો, અને ટેસ્ટ સાથે ક્રમવધ્ધ રીતે રોલઆઉટ યોજના આપો.

પર્યાવરણ: Python 3.11, FastAPI, Pydantic v2.
કોન્ટ્રેક્ટ: એન્ડપોઈન્ટ આંકડા સાથે 200 પરત આપે, ભાગે વિફળ પણ.
બંધારણ: અસંક્રિય રહેવું; કોઈ ભારે નવી નિર્ભરતા ઉમેરવી નહીં.

1) ટીકા: સબૂત સાથે ચોક્કસ મુદ્દાઓની સૂચિ બનાવી.
2) ડિફ: સુધારવા માટે નાનામાં નાનું ફેરફાર.
3) રિફેક્ટર: સ્વચ્છ અને ઊપયોગી અંતિમ કોડ.
4) ટેસ્ટ્સ: ખુશحال માર્ગ અને 3 કેજ કેસ સહિત યુનિટ ટેસ્ટ્સ.

3 રિફેક્ટર વિકલ્પ સૂચવો:
- વિકલ્પ A: ન્યૂનતમ ફેરફાર
- વિકલ્પ B: મધ્યમ પુનર્રચના
- વિકલ્પ C: પૂર્ણ પુનર્લેખન
દરેક માટે: ફાયદા/અફવડતાઓ, જટિલતા, જોખમ, માઇગ્રેશન યોજના, અને ક્યારે પસંદ કરવી તે સમજાવો.

બંધારણો: એક ZIP જાહેર 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"https://api.example.com/users/{user_id}/profile")
        posts = await client.get(f"https://api.example.com/users/{user_id}/posts")
    return {"data": {"profile": profile.json(), "posts": posts.json()}}

દરેક સૂચનને આ સાથે ટૅગ કરો: {ગંભીરતા, કેટેગરી, કારણ}. પહેલા/પછી સ્નિપેટ અને એક તબક્કાનો માઇગ્રેશન પ્લાન છે તે શામેલ કરો nếu વર્તન બદલાય શકે.

આઉટપુટ એકીકૃત ડિફ તરીકે ફાઇલ પાથ સાથે જે રેપોઝનો રુટ છે તે મુજબ પાછું આપો. માત્ર બદલાયેલા હંક્સ શામેલ કરો. ડિફમાં ટિપ્પણીઓ નહીં. પછી અલગ વિભાગમાં ટિપ્પણીઓ આપો.

નામ જરુરી બે બ્લૉકથી જવાબ આપો:
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 પાસ ચલાવો અને અપેક્ષિત ઉલ્લંઘનો સૂચિ બનાવો, પછી તેને ઠીક કરો.

દરેક ફેરફાર માટે રિફેક્ટરિંગ પેટર્ન નામ કરો (જેમ કે Extract Function, Introduce Parameter Object) અને આ કોડબેઝમાં તેનો ઉપયોગ ક્યારે કરવો તે સમજાવો.

ફક્ત રેપોઝ સંદર્ભનો ઉપયોગ કરો. આ PR માં બદલાયેલી ફાઇલો [ઉદ્દેશ્ય] માટે સમીક્ષા કરો. ગંભીરતા અને કારણથી જોડાયેલી ટિપ્પણીઓ સાથે શોધો દર્શાવો. જાહેર API અને NFRs જાળવી એવા ડિફ્સ રજૂ કરો. ફક્ત બદલાયેલી પાથ સાથે સંકળાયેલા ટેસ્ટ સમાવિષ્ટ કરો.