Clinical Research Agent Evolution

def is_clinically_relevant(text: str) -> bool:
    """Check if text is clinically relevant."""
    
    # Step 1: Check minimum length
    if len(text) < 150:
        return False

    # Step 2: Check PHI patterns
    if contains_phi(text):
        return False  # Reject content with PHI

    # Step 3: Count keyword matches
    keywords = [
        "discharge summary", "hospital course",
        "patient history", "medications",
    ]
    matches = sum(1 for kw in keywords if kw in text.lower())
    
    # Need at least 2 keyword matches
    return matches >= 2

class RateLimiter:
    """Token bucket rate limiter for smooth rate control."""
    
    def __init__(self, max_requests_per_minute: int = 6):
        self.max_rpm = max_requests_per_minute
        self.burst_size = max_requests_per_minute
        self.tokens = float(self.burst_size)  # Start full
        self.last_update = datetime.now()

    def _refill_tokens(self):
        """Add tokens based on elapsed time."""
        now = datetime.now()
        elapsed = (now - self.last_update).total_seconds()
        
        # Rate = 6/60 = 0.1 tokens per second
        tokens_to_add = elapsed * self.max_rpm / 60.0
        self.tokens = min(self.burst_size, self.tokens + tokens_to_add)
        self.last_update = now

    def acquire(self) -> bool:
        """Acquire a token, waiting if necessary."""
        while True:
            self._refill_tokens()
            if self.tokens >= 1.0:
                self.tokens -= 1.0  # Consume token
                return True
            time.sleep(0.1)  # Wait before retry

def is_indian_clinical_content(text: str) -> Tuple[bool, dict]:
    """Detect Indian clinical content with scoring."""
    text_lower = text.lower()
    score = 0
    analysis = {
        "indian_score": 0,
        "detected_hospitals": [],
        "detected_abbreviations": [],
        "detected_terms": [],
        "has_indian_pattern": False,
    }

    # Hospital detection: +2 points each (strong signal)
    INDIAN_HOSPITALS = ["AIIMS", "PGIMER", "Apollo", ...]  # 50+ hospitals
    for hospital in INDIAN_HOSPITALS:
        if hospital.lower() in text_lower:
            analysis["detected_hospitals"].append(hospital)
            score += 2

    # Abbreviation detection: +1 point each
    INDIAN_ABBREVIATIONS = ["s/o", "d/o", "w/o", "c/o", "h/o", "NAD", ...]  # 300+ abbrevs
    for abbrev in INDIAN_ABBREVIATIONS:
        if re.search(r"\b" + re.escape(abbrev) + r"\b", text, re.I):
            analysis["detected_abbreviations"].append(abbrev)
            score += 1

    # Pattern detection: +3 points each (strongest signal)
    indian_patterns = [
        r"\b(?:s/o|d/o|w/o|r/o)\s+\w+",  # Family relations
        r"\b(?:came with|presented with)\s+complaints?\s+of",  # Indian phrasing
        r"\bper\s+(?:abdomen|speculum)\b",  # Examination style
    ]
    for pattern in indian_patterns:
        if re.search(pattern, text_lower):
            analysis["has_indian_pattern"] = True
            score += 3

    analysis["indian_score"] = score
    analysis["is_indian"] = score >= 2  # Low threshold for high recall

    return analysis["is_indian"], analysis

def is_clinical_image(
    image_url: str,
    page_content: str = "",
    page_title: str = "",
    image_alt: str = "",
) -> Tuple[bool, Dict]:

    # Step 1: Combine all context for analysis
    text_to_analyze = " ".join([
        image_url.lower(),       # Analyze filename & path
        page_title.lower(),      # Page context
        image_alt.lower(),       # Image description
        page_content.lower()[:2000],  # First 2000 chars
    ])

    score = 0
    
    # Step 2: Match clinical patterns (+2 points each)
    for pattern in clinical_patterns:  # 60+ patterns
        if pattern.lower() in text_to_analyze:
            score += 2

    # Step 3: Match Indian hospitals (+3 points each)
    for hospital in INDIAN_HOSPITAL_PATTERNS:  # 45+ hospitals
        if hospital.lower() in text_to_analyze:
            score += 3

    # Step 4: URL analysis (+3 points)
    if "discharge" in urlparse(image_url).path.lower():
        score += 3

    # Classification threshold (higher than V2)
    return score >= 5, {"clinical_score": score, ...}

def process_ocr(
    image_path: str,
    languages: List[str] = ["eng", "hin"],
) -> Dict:
    """Extract text with Tesseract OCR (English+Hindi)."""
    import pytesseract
    from PIL import Image

    # Create language code: "eng+hin"
    lang_code = "+".join(languages)
    img = Image.open(image_path)

    # Get detailed OCR data with bounding boxes
    ocr_data = pytesseract.image_to_data(
        img,
        lang=lang_code,
        output_type=pytesseract.Output.DICT,
    )

    # Process word-level results
    text_blocks = []
    total_confidence = 0
    valid_blocks = 0

    for i in range(len(ocr_data["text"])):
        text = ocr_data["text"][i].strip()
        conf = ocr_data["conf"][i]  # Confidence 0-100

        # Filter by confidence threshold
        if text and conf > 60:
            text_blocks.append({
                "text": text,
                "confidence": conf,
                "left": ocr_data["left"][i],    # Bounding box
                "top": ocr_data["top"][i],
                "width": ocr_data["width"][i],
                "height": ocr_data["height"][i],
            })
            total_confidence += conf
            valid_blocks += 1

    # Get full text output
    full_text = pytesseract.image_to_string(img, lang=lang_code)
    avg_confidence = total_confidence / valid_blocks if valid_blocks > 0 else 0

    return {
        "success": True,
        "text": full_text.strip(),
        "confidence": avg_confidence,
        "language": lang_code,
        "blocks": text_blocks,
    }

def classify_document(ocr_text: str) -> str:
    """Classify document into one of 10 types."""
    
    # Ordered by specificity (most specific first)
    document_types = [
        ("discharge summary", "Discharge Summary"),
        ("discharge advice", "Discharge Summary"),
        ("prescription", "Prescription"),
        ("case sheet", "Case Sheet"),
        ("lab report", "Lab Report"),
        ("blood report", "Lab Report"),
        ("scan report", "Scan Report"),
        ("x-ray", "Scan Report"),
        ("CT scan", "Scan Report"),
        ("ECG", "ECG Report"),
        ("echocardiogram", "Echocardiogram"),
        ("ICU note", "ICU Note"),
        ("OPD", "OPD Card"),
        ("emergency", "Emergency Note"),
        # ... 10 total types
    ]

    text_lower = ocr_text.lower()
    
    # Find first matching type (ordered by specificity)
    for pattern, doc_type in document_types:
        if pattern in text_lower:
            return doc_type  # Stop at first match

    return "Unknown"