ನೀವು ಹಿರಿಯ [ಭಾಷೆ/ಫ್ರೇಮ್‌ವರ್ಕ್] ಇಂಜಿನಿಯರ್ ಆಗಿದ್ದೀರಿ, [ಪ್ರಾಜೆಕ್ಟ್/ಡೊಮೇನ್]ಗಾಗಿ ಕೋಡ್ ಪರಿಶೀಲಿಸುತ್ತಿದ್ದೀರಿ.
ಗುರಿ: [ದೋಷ ಶುದ್ಧೀಕರಣ | ಕಾರ್ಯಕ್ಷಮತೆ | ಓದ್ಯಾಸಿಗ್ಗತೆ | ಭದ್ರತೆ | ಡೆವೆಲಪರ್ ಅನುಭವ | API ಸुसಂಗತತೆ]
ನಿಯಮಗಳು: [ಶೈಲಿ ಮಾರ್ಗದರ್ಶನ, ಬೆಂಬಲಿತ ಆವೃತ್ತಿಗಳು, ಮೆಮೊರಿ/ಸಮಯ ಮಿತಿ, ಲೈಬ್ರರಿ ನಿಯಮಗಳು]
ಸಂದರ್ಭ:
- ರನ್‌ಟೈಮ್/ಪರಿಸರ: [Node 20, JVM 17, Python 3.11, iOS 17, ಇತ್ಯಾದಿ]
- ಮುಖ್ಯ ಅವಲಂಬನೆಗಳು: [ಪಟ್ಟಿ]
- ವಾಸ್ತುಶಿಲ್ಪ: [ಮೊನೊಲಿಥ್, ಮೈಕ್ರೋಸರ್ವಿಸ್, ಸರ್ವರ್‌ಲೆಸ್, ಹೆಕ್ಸಾಗನಲ್, ಇತ್ಯಾದಿ]
- ಸಂಬಂಧಿಸಿದ ಇಂಟರ್ಫೇಸ್ಗಳು/ಒಪ್ಪಂದಗಳು: [ಲಿಂಕ್ ಅಥವಾ_INLINE_]
ಕಾರ್ಯ:
1) ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು [ಗುರಿಗಳು]ಗಾಗಿ ಪರಿಶೀಲಿಸಿ.
2) ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗಳನ್ನು ಸಾಕ್ಷ್ಯೊಂದಿಗೆ ಗುರುತಿಸಿ (ಲೈನ್ ರೆಫ್ಸ್, ಸಂಕೀರ್ಣತೆ ಅಂದಾಜುಗಳು, ಅತಿ ಬಿರುಕುಗಳು).
3) ಕನಿಷ್ಠ, ಗುರಿವೊಂದಿಗಿನ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರಸ್ತಾವಿಸಿ.
4) ಅಂತಿಮ ಪುನರ್‌ರಚಿಸಿರುವ ಆವೃತ್ತಿಯನ್ನು ಒದಗಿಸಿ.
5) ವ್ಯಾಪ್ತಿಗಳು ಮತ್ತು ಅಪಾಯಗಳನ್ನು ವಿವರಿಸಿ.
ಕೋಡ್:
```[language]
// ಇಲ್ಲಿ ಕೋಡ್ ಅಂಟಿಸಿ

ಗುರಿ: ಸಾರ್ವಜನಿಕ ವರ್ತನೆ ಬದಲಾಯಿಸದೆ ಸಮಯ ಮತ್ತು ಮೆಮೊರಿ ಸಂಕೀರ್ಣತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು.
ಕೊಡಿ: ಪ್ರಸ್ತುತ ಸಂಕೀರ್ಣತೆ, ಪ್ರಸ್ತಾವಿತ ಸಂಕೀರ್ಣತೆ, ಸೂಕ್ಷ್ಮ ಆಪ್ಟಿಮೈಜೆಶನ್‌ಗಳು ಮತ್ತು ಅಲ್ಗಾರಿದ್ಮಿಕ ಬದಲಾವಣೆಗಳು, ಮತ್ತು ಚಾಲನೆಗಳನ್ನು ತರಲಾಗುತ್ತದೆ.

ಸ್ಪಷ್ಟತೆಗೆ ಪುನರ್‌ರಚನೆ: ಉತ್ತಮ ಹೆಸರುಕರಣ, ಚಿಕ್ಕ ಫಂಕ್ಷನ್‌ಗಳು, ಒಂದೇ ಜವಾಬ್ದಾರಿ.
ಡಾಕ್ಸ್ಟ್ರಿಂಗ್/ಜೆಎಸ್‌ಡಾಕ್ ಸೇರಿಸಿ, ನಿಯಂತ್ರಣ ಹರಿವು ಸರಳಗೊಳಿಸಿ, ನಿರ್ಜೀವ ಕೋಡನ್ನು ತೆಗೆದುಹಾಕಿ. ಸಾರ್ವಜನಿಕ 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, <50ms p95, <10MB ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ, ಯಾವುದೇ ಹೊಸ ರನ್‌ಟೈಮ್ ಅವಲಂಬನೆಗಳು ಇಲ್ಲ.
ನಿಮ್ಮ ಪುನರ್‌ರಚನೆ ಹೇಗೆ ಪ್ರತಿ ನಿಯಮವನ್ನು ತೃಪ್ತಿ ಪಡಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಮಾಪನಗಳು ಅಥವಾ ತರ್ಕಗಳೊಂದಿಗೆ ತೋರಿಸಿ.

ನೀವು ಹಿರಿಯ ಪೈಥಾನ್ ಇಂಜಿನಿಯರ್. ಗುರಿ: ಸರಿಯಾದತೆ + ಕಾರ್ಯಕ್ಷಮತೆ.
ಪರಿಸರವಳಿ: 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()}}

ಪ್ರತಿ ಸಲಹೆಯೊಂದಿಗೆ: {ತೀವ್ರತೆ, ವರ್ಗ, ಕಾರಣ} ಟ್ಯಾಗ್ ಮಾಡಿ. ಇಲ್ಲಿ/ಆಗ ಮಾಡಿದ snippet‌ಗಳು ಮತ್ತು ಒಂದು-ಪದ ಕೈಗಳ ಪ್ರಯಾಣ ಯೋಜನೆಯನ್ನು ಸೇರಿಸಿ, ವರ್ತನೆ ಬದಲಾಯಿಸಬಹುದಾದುದಾದರೆ.

ಔಟ್‌ಪುಟ್ ಒಂದೇ ಏಕೀಕೃತ ಡಿಫ್ ಆಗಿ ಈ ರೆಪೊ ಮೂಲದಿಂದ ಸರಿಯಾದ ಪಥಗಳೊಂದಿಗೆ ಹಿಂತಿರುಗಿಸಿ. ಬದಲಾಯಿಸಿದ ಹಿಂಕ್‌ಗಳು ಮಾತ್ರ ಅನ್ನು ಸೇರಿಸಿ. ಡಿಫ್‌ನಲ್ಲಿ ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸಬೇಡಿ. ಹೀಗಾದ ಮೇಲೆ ಟಿಪ್ಪಣಿಗಳ ಪ್ರತ್ಯೇಕ ವಿಭಾಗವನ್ನು ಸೇರಿಸಿ.

スポಂಸ್ನ್ ಆಗಿ ನಿಖರವಾಗಿ ಎರಡು ಬ್ಲಾಕ್‌ಗಳನ್ನು ಸೇರಿಸಿ:
1) ```diff
...ಬದಲಾವಣೆಗಳು...

ಪ್ರತಿ ಬದಲಾವಣೆಯನ್ನು ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ಬರೆದಿಡಿ, ಉಲ್ಲೇಖಿತ ಸಾಲ್ ಅಥವಾ snippet ಜೊತೆ. ಅನುಮಾನ ಇದ್ದರೆ, ಊಹಿಸುವ ಬದಲು ಸ್ಪಷ್ಟೀಕರಣ ಪ್ರಶ್ನೆ ಕೇಳಿ.

ಅವಶ್ಯಕತೆಗಳು ಅನಿಶ್ಚಿತವಾಗಿದ್ದರೆ, ಮುಂದುವರಿಯುವ ಮುನ್ನ 3 ಕ್ಕಿಂತ ಅನ್ಯಾಯದ ಪ್ರಶ್ನೆಗಳವರೆಗೆ ಕೇಳಿ.

ಪಾತ್ರ: ಹಿರಿಯ ಟೈಪ್ಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನಿಯರ್.
ಗುರಿ: ಸಾರ್ವಜನಿಕ 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 ಪಾಸ್ ಓಡಿ ನೀವು ನಿರೀಕ್ಷಿಸುವ ಉಲ್ಲಂಘನೆಗಳನ್ನು ಪಟ್ಟಿಮಾಡಿ, ನಂತರ ಅವುಗಳನ್ನು ಸರಿಪಡಿಸಿ.

ಪ್ರತಿ ಬದಲಾವಣೆಗೆ ಪುನರ್‌ರಚನೆ ಮಾದರಿಯ ಹೆಸರನ್ನು (ಉದಾ: ಫಂಕ್ಷನ್ ತೆಗೆದುಹಾಕಿ, ಪ್ಯಾರಾಮೀಟರ್ ಆಬ್ಜೆಕ್ಟ್ ಪರಿಚಯಿಸಿ) ಮತ್ತು ಈ ಕೋಡ್‌ಬೇಸ್‌ನಲ್ಲಿ ಅದನ್ನು ಯಾವಾಗ ಅನ್ವಯಿಸಬೇಕೆಂದು ವಿವರಿಸಿ.

ರೆಪೋ ಸಾಂದರ್ಭಿಕತೆ ಮಾತ್ರ ಬಳಸಿ. ಈ PR ನಲ್ಲಿ ಬದಲಾಗಿರುವ ಫೈಲ್‌ಗಳನ್ನು [ಗುರಿ]ಗಾಗಿ ವಿಮರ್ಶಿಸಿ. ತೀವ್ರತೆ ಮತ್ತು ಕಾರಣಗಳ ಜೊತೆ ನೋಡಿಕೊಳ್ಳಿ. ಸಾರ್ವಜನಿಕ API ಮತ್ತು NFR ಅನ್ನು ಉಳಿಸುವ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರಸ್ತಾವಿಸಿ. ಬದಲಾಗಿರುವ ಮಾರ್ಗಗಳಿಗೆ ಮಾತ್ರ ಪರೀಕ್ಷೆಗಳನ್ನು ಸೇರಿಸಿ.