phase 3 ig

Co-authored-by: Copilot <copilot@github.com>

app_new.py

@@ -33,6 +33,7 @@ from dataclasses import dataclass
 from getpass import getpass
 from pathlib import Path
 from typing import Any
+from zoneinfo import ZoneInfo
 
 try:
     from dotenv import load_dotenv
@@ -77,7 +78,7 @@ from werkzeug.middleware.proxy_fix import ProxyFix
 from flask_login import current_user, login_required
 
 # Import new security and auth modules
-from models import db, User, ScreeningReport, ScreeningUpload
+from models import db, User, ScreeningReport, ScreeningUpload, AuditLog
 from auth_utils import init_auth, log_audit, get_client_ip
 from auth_routes import auth_bp
 from data_isolation import UserDataManager
@@ -125,6 +126,49 @@ HF_MODEL_REPO = os.environ.get("ICH_HF_MODEL_REPO", "").strip()
 HF_TOKEN = os.environ.get("ICH_HF_TOKEN", "").strip()
 LOCAL_MODE = _env_bool("ICH_LOCAL_MODE", True)
 SHOW_LOGS = _env_bool("ICH_SHOW_LOGS", False)
+GPU_BATCH_ENABLED = _env_bool("ICH_GPU_BATCH_INFERENCE", True)
+GPU_BATCH_SIZE = _env_int("ICH_GPU_BATCH_SIZE", 2, minimum=1)
+GPU_QUEUE_ENABLED = _env_bool("ICH_GPU_QUEUE_ENABLED", False)
+GPU_QUEUE_NAME = os.environ.get("ICH_GPU_QUEUE_NAME", "gpu").strip() or "gpu"
+CPU_QUEUE_NAME = os.environ.get("ICH_CPU_QUEUE_NAME", "cpu").strip() or "cpu"
+IST = ZoneInfo("Asia/Kolkata")
+
+def _now_ist() -> datetime.datetime:
+    return datetime.datetime.now(IST).replace(tzinfo=None)
+
+def _as_ist(dt: datetime.datetime | None) -> datetime.datetime | None:
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=IST)
+    return dt.astimezone(IST)
+
+def _format_dt_ist(dt: datetime.datetime | None, fmt: str = "%Y-%m-%d %H:%M") -> str:
+    local = _as_ist(dt)
+    return local.strftime(fmt) if local else "—"
+
+def _format_iso_ist(value: str | None, fmt: str = "%Y-%m-%d %H:%M") -> str:
+    if not value:
+        return "—"
+    try:
+        parsed = datetime.datetime.fromisoformat(value)
+    except Exception:
+        return value[:16]
+    return _format_dt_ist(parsed, fmt)
+
+def _to_ist_naive(dt: datetime.datetime | None) -> datetime.datetime | None:
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=datetime.timezone.utc)
+    return dt.astimezone(IST).replace(tzinfo=None)
+
+def _cuda_available() -> bool:
+    try:
+        import torch
+        return torch.cuda.is_available()
+    except Exception:
+        return False
 
 # ══════════════════════════════════════════════════════════════════════════
 #  FLASK APP SETUP
@@ -316,6 +360,99 @@ def _ensure_model_loaded() -> bool:
         logger.error(f"Model loading failed: {e}", exc_info=True)
         return False
 
+
+def _gpu_batch_ready() -> bool:
+    if not GPU_BATCH_ENABLED:
+        return False
+    if not _ensure_model_loaded():
+        return False
+    return _MODEL.get("device") == "cuda"
+
+
+def _infer_images_batch(dcm_paths: list[Path]) -> list[tuple[Any, dict[str, Any]]]:
+    if not _ensure_model_loaded():
+        raise RuntimeError("Model not loaded")
+
+    ri_mod = _MODEL["inference_mod"]
+    images = [ri_mod.dicom_to_rgb(str(path), size=ri_mod.IMG_SIZE) for path in dcm_paths]
+    inferences = ri_mod.infer_batch(
+        images,
+        _MODEL["model"],
+        _MODEL["grad_cam"],
+        _MODEL["transform"],
+        _MODEL["device"],
+        _MODEL["temperature"],
+    )
+    return list(zip(images, inferences, strict=False))
+
+
+def _persist_inference_result(
+    image_id: str,
+    user_id: int,
+    upload_id: int,
+    img_rgb: Any,
+    inference: dict[str, Any],
+) -> dict[str, Any]:
+    ri_mod = _MODEL["inference_mod"]
+    user_reports_dir = UserDataManager().get_user_reports_dir(user_id)
+    user_reports_dir.mkdir(parents=True, exist_ok=True)
+
+    report = ri_mod.build_report(
+        image_id,
+        inference,
+        _MODEL["calib_cfg"],
+        user_reports_dir,
+        img_rgb,
+        true_label=None,
+    )
+
+    pred = report.get("prediction", {})
+    pred.setdefault("raw_probability", inference.get("raw_prob_any"))
+    pred.setdefault("calibrated_probability", inference.get("cal_prob_any"))
+    pred.setdefault("decision_threshold", pred.get("decision_threshold_any"))
+    report["prediction"] = pred
+
+    explainability = report.get("explainability", {}) if isinstance(report, dict) else {}
+    gradcam_reference = (
+        report.get("cloudinary_heatmap_url")
+        or explainability.get("heatmap_path")
+        or explainability.get("image_path")
+    )
+
+    report_path = user_reports_dir / f"{image_id}_report.json"
+    with open(report_path, "w") as f:
+        json.dump(report, f, separators=(",", ":"), ensure_ascii=True)
+
+    user_data_dir = UserDataManager().get_user_data_dir(user_id)
+    screening_report = ScreeningReport(
+        user_id=user_id,
+        upload_id=upload_id,
+        image_id=image_id,
+        screening_outcome=pred.get("screening_outcome"),
+        raw_probability=pred.get("raw_probability"),
+        calibrated_probability=pred.get("calibrated_probability"),
+        confidence_band=pred.get("confidence_band"),
+        decision_threshold=pred.get("decision_threshold"),
+        triage_action=report.get("triage", {}).get("action"),
+        urgency=report.get("triage", {}).get("urgency"),
+        report_json_path=str(report_path.relative_to(user_data_dir)),
+        gradcam_image_path=gradcam_reference,
+        llm_summary=report.get("llm_summary"),
+        report_payload=json.dumps(report, ensure_ascii=True, separators=(",", ":")),
+        generated_at=_now_ist(),
+    )
+    db.session.add(screening_report)
+    db.session.commit()
+
+    log_audit(
+        "inference_completed",
+        user_id=user_id,
+        resource_type="report",
+        resource_id=screening_report.id,
+        status="success",
+    )
+    return report
+
 # ══════════════════════════════════════════════════════════════════════════
 #  INFERENCE & BATCH PROCESSING
 # ══════════════════════════════════════════════════════════════════════════
@@ -331,7 +468,6 @@ def _run_inference_on_dcm(
     
     ri_mod = _MODEL["inference_mod"]
     image_id = dcm_path.stem
-    user_reports_dir = UserDataManager().get_user_reports_dir(user_id)
     
     bbr.start()
     
@@ -345,55 +481,7 @@ def _run_inference_on_dcm(
             _MODEL["device"],
             _MODEL["temperature"],
         )
-        
-        user_reports_dir.mkdir(parents=True, exist_ok=True)
-        report = ri_mod.build_report(
-            image_id, inference, _MODEL["calib_cfg"],
-            user_reports_dir, img_rgb, true_label=None,
-        )
-        
-        pred = report.get("prediction", {})
-        pred.setdefault("raw_probability", inference.get("raw_prob_any"))
-        pred.setdefault("calibrated_probability", inference.get("cal_prob_any"))
-        pred.setdefault("decision_threshold", pred.get("decision_threshold_any"))
-        report["prediction"] = pred
-
-        explainability = report.get("explainability", {}) if isinstance(report, dict) else {}
-        gradcam_reference = (
-            report.get("cloudinary_heatmap_url")
-            or explainability.get("heatmap_path")
-            or explainability.get("image_path")
-        )
-        
-        report_path = user_reports_dir / f"{image_id}_report.json"
-        with open(report_path, "w") as f:
-            json.dump(report, f, indent=2)
-        
-        # Save to database
-        user_data_dir = UserDataManager().get_user_data_dir(user_id)
-
-        screening_report = ScreeningReport(
-            user_id=user_id,
-            upload_id=upload_id,
-            image_id=image_id,
-            screening_outcome=pred.get("screening_outcome"),
-            raw_probability=pred.get("raw_probability"),
-            calibrated_probability=pred.get("calibrated_probability"),
-            confidence_band=pred.get("confidence_band"),
-            decision_threshold=pred.get("decision_threshold"),
-            triage_action=report.get("triage", {}).get("action"),
-            urgency=report.get("triage", {}).get("urgency"),
-            report_json_path=str(report_path.relative_to(user_data_dir)),
-            gradcam_image_path=gradcam_reference,
-            llm_summary=report.get("llm_summary"),
-            report_payload=json.dumps(report, ensure_ascii=True),
-            generated_at=datetime.datetime.utcnow(),
-        )
-        db.session.add(screening_report)
-        db.session.commit()
-        
-        log_audit("inference_completed", user_id=user_id, resource_type="report", 
-                 resource_id=screening_report.id, status="success")
+        report = _persist_inference_result(image_id, user_id, upload_id, img_rgb, inference)
     
     except Exception as e:
         db.session.rollback()
@@ -405,7 +493,7 @@ def _run_inference_on_dcm(
     bbr.stop()
     
     # Save trace
-    ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    ts = _now_ist().strftime("%Y%m%d_%H%M%S")
     base = f"{ts}_{image_id}"
     try:
         bbr.save_report(str(LOGS_DIR / f"{base}.txt"))
@@ -419,18 +507,25 @@ def _start_batch(dcm_paths: list[Path], user_id: int, temp_dir: str | None = Non
     """Trigger async batch processing via Celery."""
     batch_id = f"u{user_id}_{uuid.uuid4().hex[:12]}"
     dcm_paths_str = [str(p) for p in dcm_paths]
+    queue = None
+    if GPU_QUEUE_ENABLED:
+        queue = GPU_QUEUE_NAME if _cuda_available() else CPU_QUEUE_NAME
     
     # Send task to Celery worker
     try:
+        task_kwargs = {
+            "batch_id": batch_id,
+            "dcm_paths": dcm_paths_str,
+            "user_id": user_id,
+            "temp_dir": temp_dir,
+        }
+        send_kwargs = {"task_id": batch_id}
+        if queue:
+            send_kwargs["queue"] = queue
         task = celery_app.send_task(
             "tasks.process_dicom_batch",
-            kwargs={
-                "batch_id": batch_id,
-                "dcm_paths": dcm_paths_str,
-                "user_id": user_id,
-                "temp_dir": temp_dir,
-            },
-            task_id=batch_id,
+            kwargs=task_kwargs,
+            **send_kwargs,
         )
     except Exception as exc:
         logger.error("Failed to enqueue Celery batch task", exc_info=True)
@@ -440,13 +535,18 @@ def _start_batch(dcm_paths: list[Path], user_id: int, temp_dir: str | None = Non
     return batch_id
 
 
+def _iter_batches(items: list[Path], batch_size: int) -> list[list[Path]]:
+    return [items[i:i + batch_size] for i in range(0, len(items), batch_size)]
+
+
 def _run_batch_sync(dcm_paths: list[Path], user_id: int, temp_dir: str | None = None) -> dict[str, Any]:
     """Fallback synchronous batch processing when Celery is unavailable."""
     total = len(dcm_paths)
     succeeded_ids: list[str] = []
     failed_ids: list[str] = []
-    started_at = datetime.datetime.now().isoformat()
+    started_at = _now_ist().isoformat()
     sync_batch_id = f"sync_u{user_id}_{uuid.uuid4().hex[:12]}"
+    use_gpu_batch = _gpu_batch_ready() and total > 1
 
     log_audit(
         "batch_sync_started",
@@ -458,39 +558,106 @@ def _run_batch_sync(dcm_paths: list[Path], user_id: int, temp_dir: str | None =
     user_upload_dir = UserDataManager().get_user_upload_dir(user_id)
 
     try:
-        for path in dcm_paths:
-            image_id = path.stem
-
-            upload_record = ScreeningUpload(
-                user_id=user_id,
-                file_name=path.name,
-                original_filename=path.name,
-                file_size=path.stat().st_size if path.exists() else None,
-                file_path=str(path.relative_to(user_upload_dir)) if path.parent == user_upload_dir else str(path),
-                processing_status="processing",
+        if use_gpu_batch:
+            logger.info(
+                "GPU batch inference enabled (size=%s); per-image traces are skipped.",
+                GPU_BATCH_SIZE,
             )
-            db.session.add(upload_record)
-            db.session.commit()
-
-            try:
-                report, _ = _run_inference_on_dcm(path, user_id, upload_record.id)
-                if report:
-                    upload_record.processing_status = "completed"
+            for chunk in _iter_batches(dcm_paths, GPU_BATCH_SIZE):
+                upload_records: list[ScreeningUpload] = []
+                for path in chunk:
+                    upload_record = ScreeningUpload(
+                        user_id=user_id,
+                        file_name=path.name,
+                        original_filename=path.name,
+                        file_size=path.stat().st_size if path.exists() else None,
+                        file_path=str(path.relative_to(user_upload_dir)) if path.parent == user_upload_dir else str(path),
+                        processing_status="processing",
+                    )
+                    db.session.add(upload_record)
                     db.session.commit()
-                    succeeded_ids.append(image_id)
-                else:
-                    upload_record.processing_status = "failed"
-                    db.session.commit()
-                    failed_ids.append(image_id)
-            except Exception as exc:
-                logger.error(f"Sync batch failed {image_id} — {exc}", exc_info=True)
-                db.session.rollback()
-                upload_record.processing_status = "failed"
+                    upload_records.append(upload_record)
+
                 try:
-                    db.session.commit()
-                except Exception:
+                    batch_results = _infer_images_batch(chunk)
+                except Exception as exc:
+                    logger.error("GPU batch inference failed — %s", exc, exc_info=True)
+                    for path, upload_record in zip(chunk, upload_records, strict=False):
+                        image_id = path.stem
+                        db.session.rollback()
+                        upload_record.processing_status = "failed"
+                        try:
+                            db.session.commit()
+                        except Exception:
+                            db.session.rollback()
+                        failed_ids.append(image_id)
+                    continue
+
+                for (path, upload_record), (img_rgb, inference) in zip(
+                    zip(chunk, upload_records, strict=False),
+                    batch_results,
+                    strict=False,
+                ):
+                    image_id = path.stem
+                    try:
+                        report = _persist_inference_result(
+                            image_id,
+                            user_id,
+                            upload_record.id,
+                            img_rgb,
+                            inference,
+                        )
+                        if report:
+                            upload_record.processing_status = "completed"
+                            db.session.commit()
+                            succeeded_ids.append(image_id)
+                        else:
+                            upload_record.processing_status = "failed"
+                            db.session.commit()
+                            failed_ids.append(image_id)
+                    except Exception as exc:
+                        logger.error(f"Sync batch failed {image_id} — {exc}", exc_info=True)
+                        db.session.rollback()
+                        upload_record.processing_status = "failed"
+                        try:
+                            db.session.commit()
+                        except Exception:
+                            db.session.rollback()
+                        failed_ids.append(image_id)
+        else:
+            for path in dcm_paths:
+                image_id = path.stem
+
+                upload_record = ScreeningUpload(
+                    user_id=user_id,
+                    file_name=path.name,
+                    original_filename=path.name,
+                    file_size=path.stat().st_size if path.exists() else None,
+                    file_path=str(path.relative_to(user_upload_dir)) if path.parent == user_upload_dir else str(path),
+                    processing_status="processing",
+                )
+                db.session.add(upload_record)
+                db.session.commit()
+
+                try:
+                    report, _ = _run_inference_on_dcm(path, user_id, upload_record.id)
+                    if report:
+                        upload_record.processing_status = "completed"
+                        db.session.commit()
+                        succeeded_ids.append(image_id)
+                    else:
+                        upload_record.processing_status = "failed"
+                        db.session.commit()
+                        failed_ids.append(image_id)
+                except Exception as exc:
+                    logger.error(f"Sync batch failed {image_id} — {exc}", exc_info=True)
                     db.session.rollback()
-                failed_ids.append(image_id)
+                    upload_record.processing_status = "failed"
+                    try:
+                        db.session.commit()
+                    except Exception:
+                        db.session.rollback()
+                    failed_ids.append(image_id)
     finally:
         if temp_dir and Path(temp_dir).exists():
             try:
@@ -520,7 +687,7 @@ def _run_batch_sync(dcm_paths: list[Path], user_id: int, temp_dir: str | None =
         "image_ids": list(succeeded_ids),
         "current_file": "",
         "started_at": started_at,
-        "finished_at": datetime.datetime.now().isoformat(),
+        "finished_at": _now_ist().isoformat(),
         "error": None,
         "temp_dir": temp_dir,
     }
@@ -576,13 +743,7 @@ class CaseRow:
     
     @property
     def date_display(self) -> str:
-        if not self.generated_at:
-            return "—"
-        try:
-            dt = datetime.datetime.fromisoformat(self.generated_at)
-            return dt.strftime("%Y-%m-%d %H:%M")
-        except (ValueError, TypeError):
-            return self.generated_at[:16]
+        return _format_iso_ist(self.generated_at)
     
     @property
     def is_positive(self) -> bool:
@@ -1244,7 +1405,7 @@ def case_detail(image_id):
         triage=report.triage_action or "N/A",
         urgency=report.urgency or "N/A",
         generated_at=_format_date(report.generated_at),
-        date_display=(report.generated_at.strftime("%Y-%m-%d %H:%M") if report.generated_at else "—"),
+        date_display=_format_dt_ist(report.generated_at),
         report_file=Path(report.report_json_path).name if report.report_json_path else None,
         gradcam_url=gradcam_url,
         true_label=report.true_label,
@@ -1295,10 +1456,15 @@ def logs_page():
     if LOGS_DIR.exists():
         for path in sorted(LOGS_DIR.iterdir(), reverse=True)[:50]:  # Last 50 logs
             if path.suffix in (".txt", ".json"):
+                modified = datetime.datetime.fromtimestamp(
+                    path.stat().st_mtime,
+                    tz=datetime.timezone.utc,
+                )
+                modified_local = _as_ist(modified)
                 log_files.append({
                     "name": path.name,
                     "size": round(path.stat().st_size / 1024, 1),
-                    "modified": datetime.datetime.fromtimestamp(path.stat().st_mtime).isoformat(),
+                    "modified": modified_local.isoformat() if modified_local else "",
                 })
     
     return render_template("logs.html", logs=log_files)
@@ -1419,6 +1585,31 @@ def create_admin():
     db.session.commit()
     print(f"Admin user '{username}' created!")
 
+@app.cli.command()
+def migrate_utc_to_ist():
+    """Convert existing UTC timestamps to IST (run once)."""
+    with app.app_context():
+        updates = 0
+        models = {
+            User: ["created_at", "updated_at"],
+            ScreeningUpload: ["upload_timestamp"],
+            ScreeningReport: ["generated_at", "created_at"],
+            AuditLog: ["timestamp"],
+        }
+        for model, fields in models.items():
+            for row in model.query.all():
+                changed = False
+                for field in fields:
+                    value = getattr(row, field, None)
+                    updated = _to_ist_naive(value)
+                    if updated and updated != value:
+                        setattr(row, field, updated)
+                        changed = True
+                if changed:
+                    updates += 1
+        db.session.commit()
+        print(f"Migrated timestamps for {updates} rows.")
+
 # ══════════════════════════════════════════════════════════════════════════
 #  MAIN
 # ══════════════════════════════════════════════════════════════════════════

auth_routes.py

@@ -24,7 +24,7 @@ from itsdangerous import BadSignature, SignatureExpired, URLSafeTimedSerializer
 from sqlalchemy import func, or_
 
 from auth_utils import log_audit, validate_email, validate_password, validate_username
-from models import User, db
+from models import User, db, now_ist
 
 logger = logging.getLogger(__name__)
 auth_bp = Blueprint('auth', __name__, url_prefix='/auth')
@@ -57,7 +57,7 @@ def _otp_payload_from_session() -> dict:
 
 def _store_otp(email: str, purpose: str, user_id: int | None = None) -> str:
     code = _generate_otp()
-    expires_at = datetime.utcnow() + timedelta(minutes=10)
+    expires_at = now_ist() + timedelta(minutes=10)
     session[OTP_SESSION_KEY] = {
         "email": email,
         "purpose": purpose,
@@ -98,7 +98,7 @@ def _validate_otp(submitted_code: str, expected_purpose: str) -> tuple[bool, str
         _clear_otp()
         return False, "OTP is invalid. Please request a new code.", None
 
-    if datetime.utcnow() > expires_at:
+    if now_ist() > expires_at:
         _clear_otp()
         return False, "OTP expired. Please request a new code.", None
 

auth_utils.py

@@ -6,8 +6,7 @@ import logging
 from functools import wraps
 from flask import session, redirect, url_for, request, g, abort, has_request_context
 from flask_login import LoginManager, current_user
-from models import db, User, AuditLog
-from datetime import datetime
+from models import db, User, AuditLog, now_ist
 from sqlalchemy.exc import SQLAlchemyError
 
 logger = logging.getLogger(__name__)
@@ -64,7 +63,7 @@ def log_audit(action, user_id=None, resource_type=None, resource_id=None,
             resource_id=resource_id,
             details=details,
             ip_address=get_client_ip(),
-            timestamp=datetime.utcnow(),
+            timestamp=now_ist(),
             status=status
         )
         db.session.add(audit_entry)

models.py

@@ -3,12 +3,17 @@ Database models for ICH Screening Application with user authentication and priva
 """
 import os
 from datetime import datetime
+from zoneinfo import ZoneInfo
 from flask_sqlalchemy import SQLAlchemy
 from flask_login import UserMixin
 from werkzeug.security import generate_password_hash, check_password_hash
 import secrets
 
 db = SQLAlchemy()
+IST = ZoneInfo("Asia/Kolkata")
+
+def now_ist() -> datetime:
+    return datetime.now(IST).replace(tzinfo=None)
 
 
 class User(UserMixin, db.Model):
@@ -20,8 +25,8 @@ class User(UserMixin, db.Model):
     email = db.Column(db.String(120), unique=True, nullable=False, index=True)
     password_hash = db.Column(db.String(255), nullable=False)
     full_name = db.Column(db.String(120))
-    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
-    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    created_at = db.Column(db.DateTime, default=now_ist, nullable=False)
+    updated_at = db.Column(db.DateTime, default=now_ist, onupdate=now_ist)
     is_active = db.Column(db.Boolean, default=True, nullable=False)
     
     # Relationships
@@ -50,7 +55,7 @@ class ScreeningUpload(db.Model):
     original_filename = db.Column(db.String(255), nullable=False)
     file_size = db.Column(db.Integer)  # bytes
     file_path = db.Column(db.String(500), nullable=False)  # Relative to user's upload dir
-    upload_timestamp = db.Column(db.DateTime, default=datetime.utcnow, nullable=False, index=True)
+    upload_timestamp = db.Column(db.DateTime, default=now_ist, nullable=False, index=True)
     processing_status = db.Column(db.String(20), default='pending')  # pending, processing, completed, failed
     processing_error = db.Column(db.Text)  # Error message if failed
     
@@ -91,8 +96,8 @@ class ScreeningReport(db.Model):
     report_payload = db.Column(db.Text)
     
     # Generated timestamp
-    generated_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False, index=True)
-    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    generated_at = db.Column(db.DateTime, default=now_ist, nullable=False, index=True)
+    created_at = db.Column(db.DateTime, default=now_ist, nullable=False)
     
     def __repr__(self):
         return f'<ScreeningReport {self.id} - user {self.user_id} - {self.image_id}>'
@@ -109,7 +114,7 @@ class AuditLog(db.Model):
     resource_id = db.Column(db.String(255))
     details = db.Column(db.Text)  # JSON or plain text with additional info
     ip_address = db.Column(db.String(45))  # IPv4 or IPv6
-    timestamp = db.Column(db.DateTime, default=datetime.utcnow, nullable=False, index=True)
+    timestamp = db.Column(db.DateTime, default=now_ist, nullable=False, index=True)
     status = db.Column(db.String(20), default='success')  # success, failure
     
     def __repr__(self):

run_interface.py

@@ -120,11 +120,25 @@ def infer_single(
     device: str,
     temperature: float,
 ) -> dict[str, Any]:
+    return infer_batch([img_rgb], model, grad_cam, transform, device, temperature)[0]
+
+
+def infer_batch(
+    images_rgb: list[np.ndarray],
+    model,
+    grad_cam: GradCAM,
+    transform,
+    device: str,
+    temperature: float,
+) -> list[dict[str, Any]]:
     # Build 3ch tensor from the app's transform pipeline, then tile to 9ch
     # because the trained model expects 2.5D channels.
-    t3 = transform(img_rgb).unsqueeze(0).to(device)
+    if device == "cuda":
+        with torch.inference_mode():
+            t3 = torch.stack([transform(img) for img in images_rgb], dim=0).to(device)
+    else:
+        t3 = torch.stack([transform(img) for img in images_rgb], dim=0).to(device)
     t9 = torch.cat([t3, t3, t3], dim=1)
-
     if isinstance(model, list) and isinstance(grad_cam, list):
         fold_logits = []
         fold_cams = []
@@ -140,14 +154,17 @@ def infer_single(
     raw_probs = core.sigmoid_np(logits)
     cal_probs = core.sigmoid_np(logits / max(float(temperature), 1e-6))
 
-    return {
-        "raw_logits": logits,
-        "raw_probs": raw_probs,
-        "cal_probs": cal_probs,
-        "raw_prob_any": float(raw_probs[0]),
-        "cal_prob_any": float(cal_probs[0]),
-        "cam": cam,
-    }
+    results = []
+    for idx in range(len(images_rgb)):
+        results.append({
+            "raw_logits": logits[idx],
+            "raw_probs": raw_probs[idx],
+            "cal_probs": cal_probs[idx],
+            "raw_prob_any": float(raw_probs[idx][0]),
+            "cal_prob_any": float(cal_probs[idx][0]),
+            "cam": cam[idx],
+        })
+    return results
 
 
 def generate_medical_summary(inference: dict[str, Any], calib_cfg: dict[str, Any], report: dict[str, Any]) -> str:

security.py

@@ -5,8 +5,13 @@ import os
 import logging
 from flask import request
 from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
 
 logger = logging.getLogger(__name__)
+IST = ZoneInfo("Asia/Kolkata")
+
+def now_ist() -> datetime:
+    return datetime.now(IST).replace(tzinfo=None)
 
 
 def init_security(app):
@@ -157,7 +162,7 @@ def get_client_info() -> dict:
         'user_agent': request.headers.get('User-Agent', 'Unknown'),
         'endpoint': request.endpoint,
         'method': request.method,
-        'timestamp': datetime.utcnow().isoformat()
+        'timestamp': now_ist().isoformat()
     }
 
 
@@ -171,7 +176,7 @@ class RateLimiter:
     
     def is_rate_limited(self, key: str) -> bool:
         """Check if a key has exceeded rate limit"""
-        now = datetime.utcnow()
+        now = now_ist()
         window_start = now - timedelta(seconds=self.window_seconds)
         
         # Clean old entries
@@ -188,7 +193,7 @@ class RateLimiter:
     
     def record_request(self, key: str):
         """Record a request for rate limiting"""
-        now = datetime.utcnow()
+        now = now_ist()
         
         if key not in self.requests:
             self.requests[key] = []

static/css/error_pages.css

@@ -75,6 +75,7 @@
 .error-code-wrap {
   position: relative;
   display: inline-block;
+  margin-bottom: 18px;
 }
 .error-scanline {
   position: absolute;
@@ -91,17 +92,6 @@
   to   { transform:translateY(80px); opacity:0; }
 }
 
-/* SVG illustration */
-.error-illustration {
-  margin: -10px 0 28px;
-  position: relative; z-index: 1;
-  animation: float-err 4s ease-in-out infinite;
-}
-@keyframes float-err {
-  0%,100%{ transform:translateY(0); }
-  50%    { transform:translateY(-10px); }
-}
-
 /* text */
 .error-title {
   font-size: 1.6rem; font-weight: 800;
@@ -138,6 +128,12 @@
   transition: opacity .2s, transform .15s, box-shadow .2s;
   border: none; cursor: pointer;
 }
+.btn-err-primary svg,
+.btn-err-secondary svg {
+  display: block;
+  flex-shrink: 0;
+  transform: translateY(1px);
+}
 .btn-err-primary:hover {
   opacity: .9; transform: translateY(-2px);
   box-shadow: 0 6px 26px rgba(110,168,254,.45);

tasks.py

@@ -14,6 +14,7 @@ import sys
 import traceback
 from pathlib import Path
 from typing import Any
+from zoneinfo import ZoneInfo
 
 # Ensure the app directory is in the Python path so imports work in worker processes
 APP_DIR = Path(__file__).parent.absolute()
@@ -29,6 +30,22 @@ except ImportError:
 from celery import Celery, current_task
 
 logger = logging.getLogger(__name__)
+IST = ZoneInfo("Asia/Kolkata")
+
+def _now_ist() -> datetime.datetime:
+    return datetime.datetime.now(IST).replace(tzinfo=None)
+
+def _env_int(name: str, default: int | None = None, *, minimum: int | None = None) -> int | None:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    try:
+        value = int(raw)
+        if minimum is not None and value < minimum:
+            return default
+        return value
+    except ValueError:
+        return default
 
 # Extract Redis URL from environment
 REDIS_URL = os.environ.get("REDIS_URL", "redis://localhost:6379/0")
@@ -53,14 +70,27 @@ celery_app.conf.update(
     task_serializer="json",
     accept_content=["json"],
     result_serializer="json",
-    timezone="UTC",
-    enable_utc=True,
+    timezone="Asia/Kolkata",
+    enable_utc=False,
     task_track_started=True,
     task_time_limit=3600,  # 1 hour hard limit
     task_soft_time_limit=3300,  # 55 min soft limit
     result_expires=86400,  # 24 hours
 )
 
+extra_conf: dict[str, Any] = {}
+worker_concurrency = _env_int("ICH_CELERY_CONCURRENCY", None, minimum=1)
+worker_prefetch = _env_int("ICH_CELERY_PREFETCH_MULTIPLIER", None, minimum=1)
+if worker_concurrency is not None:
+    extra_conf["worker_concurrency"] = worker_concurrency
+if worker_prefetch is not None:
+    extra_conf["worker_prefetch_multiplier"] = worker_prefetch
+if extra_conf:
+    celery_app.conf.update(**extra_conf)
+
+def _iter_batches(items: list[str], batch_size: int) -> list[list[str]]:
+    return [items[i:i + batch_size] for i in range(0, len(items), batch_size)]
+
 
 @celery_app.task(bind=True, name="tasks.process_dicom_batch")
 def process_dicom_batch(
@@ -111,95 +141,257 @@ def process_dicom_batch(
     total = len(dcm_paths)
     succeeded_ids = []
     failed_ids = []
-    started_at = datetime.datetime.now().isoformat()
+    started_at = _now_ist().isoformat()
 
     logger.info(f"Batch {batch_id} starting: {total} files for user {user_id}")
 
     try:
         with app.app_context():
-            for i, path_str in enumerate(dcm_paths, 1):
-                # Check if task was revoked (compat across Celery versions)
-                request_ctx = current_task.request
-                is_revoked = bool(getattr(request_ctx, "is_revoked", False)) or bool(
-                    getattr(request_ctx, "revoked", False)
-                )
-                if is_revoked:
-                    logger.info(f"Batch {batch_id} revoked, stopping")
-                    break
-
-                path = Path(path_str)
-                image_id = path.stem
-
-                upload_record = ScreeningUpload(
-                    user_id=user_id,
-                    file_name=path.name,
-                    original_filename=path.name,
-                    file_size=path.stat().st_size if path.exists() else None,
-                    file_path=str(path),
-                    processing_status="processing",
+            use_gpu_batch = False
+            batch_size = 1
+            _infer_images_batch = None
+            _persist_inference_result = None
+            try:
+                from app_new import (
+                    GPU_BATCH_SIZE,
+                    _gpu_batch_ready,
+                    _infer_images_batch,
+                    _persist_inference_result,
                 )
-                db.session.add(upload_record)
-                db.session.commit()
-
-                # Update Celery task state with progress (matches _BATCHES format for frontend)
-                self.update_state(
-                    state="PROGRESS",
-                    meta={
-                        "batch_id": batch_id,
-                        "user_id": user_id,
-                        "status": "running",
-                        "total": total,
-                        "processed": i - 1,
-                        "succeeded": len(succeeded_ids),
-                        "failed_ids": list(failed_ids),
-                        "image_ids": list(succeeded_ids),
-                        "current_file": image_id,
-                        "started_at": started_at,
-                        "finished_at": None,
-                        "error": None,
-                        "temp_dir": temp_dir,
-                    },
+                use_gpu_batch = _gpu_batch_ready() and total > 1
+                batch_size = max(1, GPU_BATCH_SIZE)
+            except Exception:
+                use_gpu_batch = False
+
+            if use_gpu_batch and _infer_images_batch and _persist_inference_result:
+                logger.info(
+                    "GPU batch inference enabled (size=%s); per-image traces are skipped.",
+                    batch_size,
                 )
+                processed = 0
+                revoked = False
+                for chunk in _iter_batches(dcm_paths, batch_size):
+                    if revoked:
+                        break
 
-                try:
-                    report, _ = _run_inference_on_dcm(path, user_id, upload_record.id)
-                    if report:
-                        upload_record.processing_status = "completed"
-                        db.session.commit()
-                        succeeded_ids.append(image_id)
-                    else:
-                        upload_record.processing_status = "failed"
+                    paths = [Path(p) for p in chunk]
+                    upload_records: list[ScreeningUpload] = []
+                    for path in paths:
+                        request_ctx = current_task.request
+                        is_revoked = bool(getattr(request_ctx, "is_revoked", False)) or bool(
+                            getattr(request_ctx, "revoked", False)
+                        )
+                        if is_revoked:
+                            logger.info(f"Batch {batch_id} revoked, stopping")
+                            revoked = True
+                            break
+
+                        upload_record = ScreeningUpload(
+                            user_id=user_id,
+                            file_name=path.name,
+                            original_filename=path.name,
+                            file_size=path.stat().st_size if path.exists() else None,
+                            file_path=str(path),
+                            processing_status="processing",
+                        )
+                        db.session.add(upload_record)
                         db.session.commit()
-                        failed_ids.append(image_id)
-                except Exception as e:
-                    logger.error(f"Batch {batch_id}: failed {image_id} — {e}")
-                    db.session.rollback()
-                    upload_record.processing_status = "failed"
+                        upload_records.append(upload_record)
+
+                    if revoked:
+                        break
+
                     try:
-                        db.session.commit()
-                    except Exception:
+                        batch_results = _infer_images_batch(paths)
+                    except Exception as exc:
+                        logger.error(
+                            f"Batch {batch_id}: GPU batch inference failed — {exc}",
+                            exc_info=True,
+                        )
+                        for path, upload_record in zip(paths, upload_records, strict=False):
+                            image_id = path.stem
+                            db.session.rollback()
+                            upload_record.processing_status = "failed"
+                            try:
+                                db.session.commit()
+                            except Exception:
+                                db.session.rollback()
+                            failed_ids.append(image_id)
+                            processed += 1
+                            self.update_state(
+                                state="PROGRESS",
+                                meta={
+                                    "batch_id": batch_id,
+                                    "user_id": user_id,
+                                    "status": "running",
+                                    "total": total,
+                                    "processed": processed,
+                                    "succeeded": len(succeeded_ids),
+                                    "failed_ids": list(failed_ids),
+                                    "image_ids": list(succeeded_ids),
+                                    "current_file": "",
+                                    "started_at": started_at,
+                                    "finished_at": None,
+                                    "error": None,
+                                    "temp_dir": temp_dir,
+                                },
+                            )
+                        continue
+
+                    for (path, upload_record), (img_rgb, inference) in zip(
+                        zip(paths, upload_records, strict=False),
+                        batch_results,
+                        strict=False,
+                    ):
+                        image_id = path.stem
+                        self.update_state(
+                            state="PROGRESS",
+                            meta={
+                                "batch_id": batch_id,
+                                "user_id": user_id,
+                                "status": "running",
+                                "total": total,
+                                "processed": processed,
+                                "succeeded": len(succeeded_ids),
+                                "failed_ids": list(failed_ids),
+                                "image_ids": list(succeeded_ids),
+                                "current_file": image_id,
+                                "started_at": started_at,
+                                "finished_at": None,
+                                "error": None,
+                                "temp_dir": temp_dir,
+                            },
+                        )
+
+                        try:
+                            report = _persist_inference_result(
+                                image_id,
+                                user_id,
+                                upload_record.id,
+                                img_rgb,
+                                inference,
+                            )
+                            if report:
+                                upload_record.processing_status = "completed"
+                                db.session.commit()
+                                succeeded_ids.append(image_id)
+                            else:
+                                upload_record.processing_status = "failed"
+                                db.session.commit()
+                                failed_ids.append(image_id)
+                        except Exception as exc:
+                            logger.error(f"Batch {batch_id}: failed {image_id} — {exc}")
+                            db.session.rollback()
+                            upload_record.processing_status = "failed"
+                            try:
+                                db.session.commit()
+                            except Exception:
+                                db.session.rollback()
+                            failed_ids.append(image_id)
+
+                        processed += 1
+                        self.update_state(
+                            state="PROGRESS",
+                            meta={
+                                "batch_id": batch_id,
+                                "user_id": user_id,
+                                "status": "running",
+                                "total": total,
+                                "processed": processed,
+                                "succeeded": len(succeeded_ids),
+                                "failed_ids": list(failed_ids),
+                                "image_ids": list(succeeded_ids),
+                                "current_file": "",
+                                "started_at": started_at,
+                                "finished_at": None,
+                                "error": None,
+                                "temp_dir": temp_dir,
+                            },
+                        )
+            else:
+                for i, path_str in enumerate(dcm_paths, 1):
+                    # Check if task was revoked (compat across Celery versions)
+                    request_ctx = current_task.request
+                    is_revoked = bool(getattr(request_ctx, "is_revoked", False)) or bool(
+                        getattr(request_ctx, "revoked", False)
+                    )
+                    if is_revoked:
+                        logger.info(f"Batch {batch_id} revoked, stopping")
+                        break
+
+                    path = Path(path_str)
+                    image_id = path.stem
+
+                    upload_record = ScreeningUpload(
+                        user_id=user_id,
+                        file_name=path.name,
+                        original_filename=path.name,
+                        file_size=path.stat().st_size if path.exists() else None,
+                        file_path=str(path),
+                        processing_status="processing",
+                    )
+                    db.session.add(upload_record)
+                    db.session.commit()
+
+                    # Update Celery task state with progress (matches _BATCHES format for frontend)
+                    self.update_state(
+                        state="PROGRESS",
+                        meta={
+                            "batch_id": batch_id,
+                            "user_id": user_id,
+                            "status": "running",
+                            "total": total,
+                            "processed": i - 1,
+                            "succeeded": len(succeeded_ids),
+                            "failed_ids": list(failed_ids),
+                            "image_ids": list(succeeded_ids),
+                            "current_file": image_id,
+                            "started_at": started_at,
+                            "finished_at": None,
+                            "error": None,
+                            "temp_dir": temp_dir,
+                        },
+                    )
+
+                    try:
+                        report, _ = _run_inference_on_dcm(path, user_id, upload_record.id)
+                        if report:
+                            upload_record.processing_status = "completed"
+                            db.session.commit()
+                            succeeded_ids.append(image_id)
+                        else:
+                            upload_record.processing_status = "failed"
+                            db.session.commit()
+                            failed_ids.append(image_id)
+                    except Exception as e:
+                        logger.error(f"Batch {batch_id}: failed {image_id} — {e}")
                         db.session.rollback()
-                    failed_ids.append(image_id)
-
-                # Update after processing each file
-                self.update_state(
-                    state="PROGRESS",
-                    meta={
-                        "batch_id": batch_id,
-                        "user_id": user_id,
-                        "status": "running",
-                        "total": total,
-                        "processed": i,
-                        "succeeded": len(succeeded_ids),
-                        "failed_ids": list(failed_ids),
-                        "image_ids": list(succeeded_ids),
-                        "current_file": "",
-                        "started_at": started_at,
-                        "finished_at": None,
-                        "error": None,
-                        "temp_dir": temp_dir,
-                    },
-                )
+                        upload_record.processing_status = "failed"
+                        try:
+                            db.session.commit()
+                        except Exception:
+                            db.session.rollback()
+                        failed_ids.append(image_id)
+
+                    # Update after processing each file
+                    self.update_state(
+                        state="PROGRESS",
+                        meta={
+                            "batch_id": batch_id,
+                            "user_id": user_id,
+                            "status": "running",
+                            "total": total,
+                            "processed": i,
+                            "succeeded": len(succeeded_ids),
+                            "failed_ids": list(failed_ids),
+                            "image_ids": list(succeeded_ids),
+                            "current_file": "",
+                            "started_at": started_at,
+                            "finished_at": None,
+                            "error": None,
+                            "temp_dir": temp_dir,
+                        },
+                    )
 
         # Cleanup temporary directory if provided
         if temp_dir and Path(temp_dir).exists():
@@ -231,7 +423,7 @@ def process_dicom_batch(
             "image_ids": list(succeeded_ids),
             "current_file": "",
             "started_at": started_at,
-            "finished_at": datetime.datetime.now().isoformat(),
+            "finished_at": _now_ist().isoformat(),
             "error": None,
             "temp_dir": temp_dir,
         }

templates/404.html

@@ -28,31 +28,6 @@
     <div class="error-scanline"></div>
   </div>
 
-  <!-- Inline SVG illustration (floating brain scan) -->
-  <div class="error-illustration">
-    <svg width="160" height="110" viewBox="0 0 160 110" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <!-- CT scan ring -->
-      <ellipse cx="80" cy="55" rx="72" ry="48" stroke="#243356" stroke-width="1.5"/>
-      <ellipse cx="80" cy="55" rx="56" ry="36" stroke="#1e3060" stroke-width="1"/>
-      <!-- gantry frame -->
-      <rect x="8" y="18" width="12" height="74" rx="4" fill="#162244" stroke="#243356" stroke-width="1"/>
-      <rect x="140" y="18" width="12" height="74" rx="4" fill="#162244" stroke="#243356" stroke-width="1"/>
-      <!-- scan table -->
-      <rect x="28" y="50" width="104" height="10" rx="4" fill="#111c33" stroke="#243356" stroke-width="1"/>
-      <!-- question mark inside -->
-      <text x="80" y="63" text-anchor="middle" font-family="Inter,sans-serif" font-size="28" font-weight="900"
-            fill="url(#qgrad)" opacity=".9">?</text>
-      <!-- sweep arc -->
-      <path d="M80 7 A48 48 0 0 1 128 55" stroke="#6ea8fe" stroke-width="1.5" stroke-dasharray="6 4" opacity=".4"/>
-      <defs>
-        <linearGradient id="qgrad" x1="0" y1="0" x2="1" y2="1">
-          <stop offset="0%" stop-color="#6ea8fe"/>
-          <stop offset="100%" stop-color="#a78bfa"/>
-        </linearGradient>
-      </defs>
-    </svg>
-  </div>
-
   <h1 class="error-title">Page Not Found</h1>
   <p class="error-desc">
     We couldn't find the page you were looking for. It may have been moved, deleted,