```json
{
  "decision": "BUY",
  "symbol": "PSO",
  "amount_pkr": 50000,
  "reason": "Strong bullish momentum observed on 4-hour chart."
}

Agar aap is poori string pe `json.loads()` chalaogay, tou aagay se `JSONDecodeError` ka thappar paray ga.

**Example 2: Extra Commentary**
AI kabhi kabhi insaanon ki tarah behave karta hai. Woh aapko JSON se pehle ya baad mein extra text de dega.

```text
Of course! Based on your request, here is the trading signal:
{
  "decision": "SELL",
  "symbol": "UBL",
  "amount_pkr": 75000,
  "reason": "Approaching major resistance level. RSI is overbought."
}
I hope this helps with your trading strategy!

import json
import re

def safe_parse_json(text: str | None) -> dict | list | None:
    """
    AI ka output parse karo — handles markdown, extra text, everything.
    Yeh function production mein ZAROORAT hai.
    """
    # Guard clause: Agar text hi nahi hai, tou aagay kya karna?
    if not text:
        return None
    
    # Step 1: Markdown code blocks ko hatao.
    # r'```json\s*' -> ```json ke baad jitni bhi space hai, usko remove karo
    # r'```\s*' -> Baaki ke ``` ko bhi remove karo
    text = re.sub(r'```json\s*', '', text)
    text = re.sub(r'```\s*', '', text)
    
    # Step 2: "Happy Path" - Koshish karo ke text ab saaf ho gaya hai.
    # .strip() se leading/trailing whitespace khatam ho jayega.
    try:
        return json.loads(text.strip())
    except json.JSONDecodeError:
        # Agar yahan fail hua, iska matlab hai abhi bhi extra text hai.
        pass
    
    # Step 3: Regex se JSON object dhoondo. Yeh sab se powerful step hai.
    # Yeh pattern pehle '{' se le kar aakhri matching '}' tak sab kuch extract kar lega.
    match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', text)
    if match:
        try:
            return json.loads(match.group())
        except json.JSONDecodeError:
            # Ho sakta hai object ke andar koi ghalat format ho.
            pass
    
    # Step 4: Agar object nahi mila, tou JSON array dhoondo.
    # Same logic as above, but for square brackets [ ... ].
    match = re.search(r'\[[^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*\]', text)
    if match:
        try:
            return json.loads(match.group())
        except json.JSONDecodeError:
            pass
            
    # Step 5: Agar kuch bhi kaam na kare, tou give up. Crash mat ho.
    return None

# Chalo isko test kartay hain messy AI output ke saath
messy_ai_output = """
Hello! As per your request for a trade on the Pakistan Stock Exchange, 
I've analyzed the market. Here's my decision:

```json
{
    "decision": "BUY",
    "symbol": "LUCK",
    "amount_pkr": 150000,
    "confidence_score": 0.85
}

**Output:**

Dekha? Function ne pehle ````json` aur ```` ko hataya. Phir usne dekha ke extra text abhi bhi hai, isliye direct `json.loads` fail ho gaya. Aakhir mein, usne regex use kar ke sirf `{...}` wala hissa extract kiya aur usko successfully parse kar diya.

> **Pro Tip: Logging is Your Best Friend**
>
> Jab `safe_parse_json` function `None` return kare, tou sirf chup chaap fail mat ho. Uss original `text` ko log zaroor karo. Kyun?
>
> 1.  **Debugging:** Aapko pata chalega ke AI kis qisam ka "ganda" response bhej raha hai.
> 2.  **Prompt Improvement:** Agar aap dekhtay hain ke AI baar baar ek hi tarah ka ghalat format bhej raha hai, tou aap ja kar apna prompt theek kar saktay hain.
>
> Hamaray `scanner.py` mein, jab bhi parsing fail hoti hai, hum usko log karte hain for debugging and future improvement.

Reliable JSON parsing ensures your bot can process AI outputs without crashes or data loss.

---

## 📺 Recommended Videos & Resources
- **[JSON Parsing in Python](https://docs.python.org/3/library/json.html)** — json module reference
  - Type: Python Official Docs
  - Link description: Learn json.loads() and error handling
- **[Pydantic for Data Validation](https://docs.pydantic.dev/)** — Type-safe data parsing
  - Type: Official Documentation
  - Link description: Learn Pydantic models for robust validation
- **[Error Recovery Patterns](https://www.youtube.com/results?search_query=python+error+recovery+patterns+graceful+degradation)** — Handling parsing failures
  - Type: YouTube
  - Link description: Search "Python error recovery and fallbacks"
- **[Regex for Text Extraction](https://docs.python.org/3/library/re.html)** — Advanced string parsing
  - Type: Python Official Docs
  - Link description: Learn regex for extracting JSON from LLM responses
- **[Prompt Engineering for Consistent Outputs](https://www.youtube.com/results?search_query=claude+prompt+engineering+json+output+format)** — Getting reliable formats
  - Type: YouTube
  - Link description: Search "Claude prompt engineering for JSON outputs"

---

## 🎯 Mini-Challenge
**5-Minute Practical Task:** Create a robust JSON parser function that: (1) Handles valid JSON, (2) Extracts JSON from markdown code blocks (```json...```), (3) Falls back to default values if parsing fails, (4) Logs the failure for debugging. Test with 5 different malformed responses to ensure graceful handling.

---

## 🖼️ Visual Reference

---