Architecture

from fastapi import FastAPI
from starlette.middleware.cors import CORSMiddleware
from mangum import Mangum

from src.api.routers.models import router as models_router
from src.api.middleware.log_requests import DeepASGILogger

# Create FastAPI app
app = FastAPI(title="SOTeam4P2 API")

# Add logging middleware
app.add_middleware(DeepASGILogger)

# Configure CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://sot4-model-registry-dev.s3-website.us-east-2.amazonaws.com"],
    allow_credentials=False,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Mount API routers
app.include_router(models_router, prefix="/api")

# AWS Lambda handler
handler = Mangum(app)

class DeepASGILogger:
    def __init__(self, app: ASGIApp):
        self.app = app

    async def __call__(self, scope: Scope, receive: Receive, send: Send):
        if scope["type"] != "http":
            await self.app(scope, receive, send)
            return

        rid = str(uuid.uuid4())[:8]
        method = scope.get("method")
        path = scope.get("path")

        # Capture request body
        body_bytes = b""
        async def recv_wrapper():
            nonlocal body_bytes
            msg = await receive()
            if msg["type"] == "http.request":
                body_bytes += msg.get("body", b"")
            return msg

        # Capture response
        resp_body = b""
        status_code = None
        async def send_wrapper(message):
            nonlocal resp_body, status_code
            if message["type"] == "http.response.start":
                status_code = message["status"]
            if message["type"] == "http.response.body":
                resp_body += message.get("body", b"")
            await send(message)

        start = time.time()
        await self.app(scope, recv_wrapper, send_wrapper)
        duration_ms = round((time.time() - start) * 1000, 2)

        # Log complete request/response with timing
        print(f"[{rid}] {method} {path} -> {status_code} ({duration_ms}ms)")

class RegistryService:
    def __init__(self, bucket_name: str, key: str = "registry/registry.json"):
        self.s3 = boto3.client("s3")
        self.bucket = bucket_name
        self.key = key
        self._models: List[Dict[str, Any]] = []
        self._id_counter: int = 0
        self._load()

    def _load(self):
        """Load registry.json from S3 safely."""
        try:
            obj = self.s3.get_object(Bucket=self.bucket, Key=self.key)
            content = obj["Body"].read()
            data = json.loads(content)
            self._models = data.get("models", [])
            self._id_counter = data.get("id_counter", 0)
        except Exception as e:
            logger.error(f"Failed to load registry: {e}")
            self._models = []
            self._id_counter = 0

    def create(self, m) -> Dict[str, Any]:
        """Create new artifact entry."""
        self._load()
        self._id_counter += 1
        new_id = str(self._id_counter)
        entry = {
            "id": new_id,
            "name": getattr(m, "name", "Unnamed Model"),
            "version": getattr(m, "version", "1.0.0"),
            "metadata": dict(m.metadata) if hasattr(m, "metadata") else {},
        }
        self._models.append(entry)
        self._save()
        return entry

class ScoringService:
    def __init__(self):
        token = os.getenv("HUGGINGFACE_HUB_TOKEN")
        self.api = HfApi(token=token)

    def _build_resource(self, model_ref: str) -> Dict[str, Any]:
        """Fetch model metadata from HuggingFace."""
        resource = {
            "name": model_ref,
            "url": f"https://huggingface.co/{model_ref}",
        }
        info = self.api.model_info(model_ref)
        resource["license"] = getattr(info, "license", None)
        resource["tags"] = getattr(info, "tags", [])
        resource["downloads"] = getattr(info, "downloads", 0)
        
        # Read model card
        readme_path = self.api.hf_hub_download(model_ref, "README.md")
        with open(readme_path, "r") as f:
            resource["card_text"] = f.read()
        
        return resource

    def rate(self, resource: Any) -> Dict[str, Any]:
        """Compute all metrics for a model."""
        hf_id = normalize_hf_id(resource.get("name"))
        base_resource = {
            "name": hf_id,
            "url": f"https://huggingface.co/{hf_id}",
            "category": "MODEL",
        }
        # Compute metrics via run.py
        metrics = compute_metrics_for_model(base_resource)
        return metrics

class Storage:
    def put_bytes(self, key: str, data: bytes):
        """Store arbitrary bytes (ZIP, binary, text)."""
        if LOCAL_MODE:
            path = os.path.join(LOCAL_DIR, key)
            os.makedirs(os.path.dirname(path), exist_ok=True)
            with open(path, "wb") as f:
                f.write(data)
        else:
            s3_client.put_object(Bucket=BUCKET, Key=key, Body=data)

    def presign(self, key: str, expires: int = 3600) -> str:
        """Generate presigned download URL."""
        if LOCAL_MODE:
            return f"local://download/{key}"
        return s3_client.generate_presigned_url(
            "get_object",
            Params={"Bucket": BUCKET, "Key": key},
            ExpiresIn=expires,
        )

def _score_local_reproducibility(local_dir: str) -> float:
    """Inspect local repository for reproducibility signals."""
    score = 0.0
    p = Path(local_dir)
    
    # requirements.txt → +0.4
    if any(f.name.lower().startswith("requirements") for f in p.iterdir()):
        score += 0.4
    
    # environment.yml → +0.2
    if any(f.name.lower().startswith("environment") for f in p.iterdir()):
        score += 0.2
    
    # Jupyter notebooks → +0.2
    if any(f.suffix.lower() == ".ipynb" for f in p.iterdir()):
        score += 0.2
    
    # README mentions "reproduce" → +0.2
    for readme in p.glob("README*"):
        text = readme.read_text(encoding="utf-8", errors="ignore").lower()
        if "reproduce" in text:
            score += 0.2
            break
    
    return min(score, 1.0)

def metric(resource: Dict[str, Any]) -> Tuple[float, int]:
    start = time.perf_counter()
    local_dir = resource.get("local_dir") or resource.get("local_path")
    
    if local_dir and os.path.isdir(local_dir):
        score = _score_local_reproducibility(local_dir)
    else:
        score = _score_remote_reproducibility(resource)
    
    latency = int((time.perf_counter() - start) * 1000)
    return round(score, 3), latency

from mangum import Mangum

app = FastAPI(title="SOTeam4P2 API")
# ... middleware and routes ...

# Lambda handler
handler = Mangum(app)