monkeybrain-runtime 1.0.0__py3-none-any.whl

services/auth/routers/teams.py

@@ -0,0 +1,112 @@
+from fastapi import APIRouter, HTTPException, Depends, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.auth.models.teams import (
+    TeamCreate,
+    TeamUpdate,
+    TeamResponse,
+    PaginatedTeamResponse,
+)
+from services.auth.helpers import teams as crud
+
+router = APIRouter()
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+# ── List (with filters) ──────────────────────────────────────────────────────
+
+@router.get("/", response_model=PaginatedTeamResponse)
+async def list_teams(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1),
+    department_id: str | None = Query(None),
+    search: str | None = Query(None),
+    sort_desc: bool = Query(True),
+
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-teams")),
+):
+    teams, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+        department_id=department_id,
+        search=search,
+        sort_desc=sort_desc,
+    )
+
+    return PaginatedTeamResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=teams,
+    )
+
+# ── Get by department ─────────────────────────────────────────────────────────
+
+@router.get("/by-department/{department_id}", response_model=list[TeamResponse])
+async def list_teams_by_department(
+    department_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-teams")),
+):
+    return await crud.get_by_department(db, department_id)
+
+
+# ── Get one ───────────────────────────────────────────────────────────────────
+
+@router.get("/{team_id}", response_model=TeamResponse)
+async def get_team(
+    team_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-teams")),
+):
+    record = await crud.get_by_id(db, team_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Team '{team_id}' not found")
+    return record
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=TeamResponse, status_code=status.HTTP_201_CREATED)
+async def create_team(
+    data: TeamCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-teams")),
+):
+    if await crud.get_by_id(db, data.team_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Team '{data.team_id}' already exists")
+    return await crud.create(db, data)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{team_id}", response_model=TeamResponse)
+async def update_team(
+    team_id: str,
+    data: TeamUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-teams")),
+):
+    updated = await crud.update(db, team_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Team '{team_id}' not found")
+    return updated
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{team_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_team(
+    team_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-teams")),
+):
+    if not await crud.delete(db, team_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Team '{team_id}' not found")
+
+# TODO: Add endpoint to list all users in a team, e.g. GET /api/v1/teams/{team_id}/users

services/auth/routers/users.py

@@ -0,0 +1,131 @@
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.auth.models.users import UserEntryResponse, PaginatedUserEntryResponse
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.auth.helpers.users import UserEntryCreate, UserEntryUpdate
+from services.auth.helpers import users as crud
+
+router = APIRouter()
+
+
+def get_db() -> AsyncIOMotorDatabase:
+    return get_database()
+
+
+@router.get("/", response_model=PaginatedUserEntryResponse)
+async def list_users(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-users")),
+):
+    users, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedUserEntryResponse(total=total, page=page, page_size=page_size, results=users)
+
+
+@router.get("/by-employee/{employee_id}", response_model=UserEntryResponse)
+async def get_user_by_employee_id(
+    employee_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-users")),
+):
+    record = await crud.get_by_employee_id(db, employee_id)
+    if not record:
+        raise HTTPException(404, detail=f"User with employee_id '{employee_id}' not found")
+    return record
+
+
+@router.get("/by-department/{department}", response_model=list[UserEntryResponse])
+async def get_users_by_department(
+    department: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-users")),
+):
+    return await crud.get_by_department(db, department)
+
+
+@router.get("/by-team/{team}", response_model=list[UserEntryResponse])
+async def get_users_by_team(
+    team: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-users")),
+):
+    return await crud.get_by_team(db, team)
+
+
+@router.get("/{user_id}", response_model=UserEntryResponse)
+async def get_user(
+    user_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-users")),
+):
+    record = await crud.get_by_id(db, user_id)
+    if not record:
+        raise HTTPException(404, detail=f"User '{user_id}' not found")
+    return record
+
+
+@router.post("/", response_model=UserEntryResponse, status_code=status.HTTP_201_CREATED)
+async def create_user(
+    data: UserEntryCreate,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-create-user")),
+):
+    if await crud.get_by_id(db, data.user_id):
+        raise HTTPException(409, detail=f"User '{data.user_id}' already exists")
+    try:
+        return await crud.create(db, data)
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
+
+
+@router.patch("/{user_id}", response_model=UserEntryResponse)
+async def update_user(
+    user_id: str,
+    data: UserEntryUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-update-user")),
+):
+    try:
+        updated = await crud.update(db, user_id, data)
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
+    if not updated:
+        raise HTTPException(404, detail=f"User '{user_id}' not found")
+    return updated
+
+
+@router.delete("/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_user(
+    user_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-delete-user")),
+):
+    if not await crud.delete(db, user_id):
+        raise HTTPException(404, detail=f"User '{user_id}' not found")
+    
+@router.get("/by-email/{email}", response_model=UserEntryResponse)
+async def get_user_by_email(
+    email: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-users")),
+):
+    record = await crud.get_by_email(db, email)
+    if not record:
+        raise HTTPException(404, detail=f"User with email '{email}' not found")
+    return record
+
+
+@router.get("/by-username/{username}", response_model=UserEntryResponse)
+async def get_user_by_username(
+    username: str,
+    db: AsyncIOMotorDatabase = Depends(get_db),
+    _: dict = Depends(require_permission("perm-view-users")),
+):
+    record = await crud.get_by_username(db, username)
+    if not record:
+        raise HTTPException(404, detail=f"User with username '{username}' not found")
+    return record

services/auth/routers/websocket_events.py

@@ -0,0 +1,247 @@
+import base64
+import json
+import logging
+from datetime import datetime, timezone
+from uuid import uuid4
+
+from fastapi import APIRouter, Body, Depends, WebSocket, WebSocketDisconnect, status
+from jose import JWTError
+
+from services.auth.helpers import nats_store, websocket_broadcast
+from services.auth.helpers.tokens import decode_access_token
+from services.common.auth import get_current_user
+from services.common.config import settings
+from services.common.event_types import infer_event_type
+
+
+router = APIRouter()
+log = logging.getLogger("uvicorn.error")
+
+
+def _payload_summary(payload) -> dict:
+    if not isinstance(payload, dict):
+        return {"payload_kind": type(payload).__name__}
+    return {
+        "payload_id": payload.get("id"),
+        "category": payload.get("category"),
+        "scope": payload.get("scope"),
+        "type": payload.get("type"),
+        "work_order_id": payload.get("work_order_id"),
+    }
+
+
+def _token_from_websocket(websocket: WebSocket) -> str | None:
+    query_token = websocket.query_params.get("token")
+    if query_token:
+        return query_token
+
+    authorization = websocket.headers.get("authorization")
+    if authorization and authorization.lower().startswith("bearer "):
+        return authorization[7:].strip()
+    return None
+
+
+async def _authenticate(websocket: WebSocket) -> dict:
+    token = _token_from_websocket(websocket)
+    if not token:
+        log.warning("WebSocket connection rejected: missing bearer token")
+        await websocket.accept()
+        await websocket.send_json({"status": "error", "detail": "Bearer token required"})
+        await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
+        return {}
+
+    try:
+        return decode_access_token(token)
+    except JWTError:
+        log.warning("WebSocket connection rejected: invalid or expired token")
+        await websocket.accept()
+        await websocket.send_json({"status": "error", "detail": "Invalid or expired token"})
+        await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
+        return {}
+
+
+def _event_payload(message: dict, current_user: dict) -> dict:
+    payload_type = "text"
+    payload = None
+
+    if message.get("text") is not None:
+        text = message["text"]
+        try:
+            payload = json.loads(text)
+            payload_type = "json"
+        except json.JSONDecodeError:
+            payload = text
+    elif message.get("bytes") is not None:
+        payload = base64.b64encode(message["bytes"]).decode("ascii")
+        payload_type = "binary_base64"
+
+    if isinstance(payload, dict) and _looks_like_event_envelope(payload):
+        return _normalize_event_envelope(payload, current_user, source="websocket")
+
+    return _new_event_envelope(payload, current_user, source="websocket", payload_type=payload_type)
+
+
+def _api_event_payload(payload: dict, current_user: dict) -> dict:
+    if _looks_like_event_envelope(payload):
+        return _normalize_event_envelope(payload, current_user, source=str(payload.get("source") or "api"))
+    if payload.get("text") is not None or payload.get("bytes") is not None:
+        return _event_payload(payload, current_user)
+    return _new_event_envelope(payload, current_user, source="api", payload_type="json")
+
+
+def _looks_like_event_envelope(payload: dict) -> bool:
+    return (
+        isinstance(payload, dict)
+        and "payload" in payload
+        and (
+            "payload_type" in payload
+            or "event_id" in payload
+            or "received_at" in payload
+            or "source" in payload
+        )
+    )
+
+
+def _new_event_envelope(
+    payload,
+    current_user: dict,
+    *,
+    source: str,
+    payload_type: str,
+) -> dict:
+    return {
+        "event_id": str(uuid4()),
+        "received_at": datetime.now(timezone.utc).isoformat(),
+        "source": source,
+        "event_type": infer_event_type({"payload": payload}),
+        "subject": settings.NATS_EVENTS_SUBJECT,
+        "user_id": current_user.get("sub") or current_user.get("user_id"),
+        "payload_type": payload_type,
+        "payload": payload,
+    }
+
+
+def _normalize_event_envelope(payload: dict, current_user: dict, *, source: str) -> dict:
+    event = dict(payload)
+    event["event_id"] = str(event.get("event_id") or uuid4())
+    event["received_at"] = str(event.get("received_at") or datetime.now(timezone.utc).isoformat())
+    event["source"] = str(event.get("source") or source)
+    event["event_type"] = str(event.get("event_type") or infer_event_type(event))
+    event["subject"] = str(event.get("subject") or settings.NATS_EVENTS_SUBJECT)
+    event["user_id"] = str(
+        event.get("user_id")
+        or current_user.get("sub")
+        or current_user.get("user_id")
+        or ""
+    )
+    event["payload_type"] = str(event.get("payload_type") or ("json" if isinstance(event.get("payload"), dict) else "text"))
+    return event
+
+
+async def _publish_event(event: dict) -> None:
+    log.info(
+        "Publishing scan event to NATS event_id=%s source=%s subject=%s payload_type=%s summary=%s",
+        event.get("event_id"),
+        event.get("source"),
+        event.get("subject"),
+        event.get("payload_type"),
+        _payload_summary(event.get("payload")),
+    )
+    subject = await nats_store.publish_typed_event(event)
+    log.info(
+        "Published scan event to NATS event_id=%s subject=%s summary=%s",
+        event.get("event_id"),
+        subject,
+        _payload_summary(event.get("payload")),
+    )
+
+
+@router.post("/events", status_code=status.HTTP_202_ACCEPTED)
+async def publish_event_from_api(
+    payload: dict = Body(...),
+    current_user: dict = Depends(get_current_user),
+):
+    event = _api_event_payload(payload, current_user)
+    log.info(
+        "HTTP scan event received event_id=%s user_id=%s summary=%s",
+        event["event_id"],
+        event["user_id"],
+        _payload_summary(payload),
+    )
+    await _publish_event(event)
+    return {
+        "status": "published",
+        "event_id": event["event_id"],
+        "subject": event.get("subject"),
+    }
+
+
+@router.websocket("/events")
+async def websocket_event_listener(websocket: WebSocket):
+    current_user = await _authenticate(websocket)
+    if not current_user:
+        return
+
+    user_id = current_user.get("sub") or current_user.get("user_id")
+    await websocket.accept()
+    log.info(
+        "WebSocket connected user_id=%s client=%s subject=%s",
+        user_id,
+        websocket.client,
+        settings.NATS_EVENTS_SUBJECT,
+    )
+    await websocket.send_json({
+        "status": "connected",
+        "subject_prefix": settings.NATS_EVENT_TYPE_SUBJECT_PREFIX,
+    })
+    await websocket_broadcast.add_connection(websocket)
+
+    try:
+        while True:
+            message = await websocket.receive()
+            if message.get("type") == "websocket.disconnect":
+                break
+
+            event = _event_payload(message, current_user)
+            payload_size = len(message.get("text") or message.get("bytes") or b"")
+            log.info(
+                "WebSocket scan event received event_id=%s user_id=%s payload_type=%s payload_size=%s summary=%s",
+                event["event_id"],
+                user_id,
+                event["payload_type"],
+                payload_size,
+                _payload_summary(event.get("payload")),
+            )
+            try:
+                await _publish_event(event)
+            except Exception as exc:
+                log.exception(
+                    "WebSocket event publish failed event_id=%s user_id=%s subject=%s",
+                    event["event_id"],
+                    user_id,
+                    event.get("subject"),
+                )
+                await websocket.send_json({
+                    "status": "nack",
+                    "event_id": event["event_id"],
+                    "subject": event.get("subject"),
+                    "detail": f"Failed to publish event to NATS: {exc}",
+                })
+                continue
+            log.info(
+                "WebSocket event published event_id=%s user_id=%s subject=%s",
+                event["event_id"],
+                user_id,
+                event.get("subject"),
+            )
+            await websocket.send_json({
+                "status": "published",
+                "event_id": event["event_id"],
+                "subject": event.get("subject"),
+            })
+    except WebSocketDisconnect:
+        log.info("WebSocket disconnected user_id=%s client=%s", user_id, websocket.client)
+        await websocket_broadcast.remove_connection(websocket)
+        return
+    log.info("WebSocket disconnected user_id=%s client=%s", user_id, websocket.client)
+    await websocket_broadcast.remove_connection(websocket)

services/batch_execution/__init__.py

@@ -0,0 +1,19 @@
+"""Batch execution module - orchestrates batch workflow execution."""
+
+from services.batch_execution.workflow_executor import (
+    BatchWorkflowExecution,
+    QCCheckpoint,
+    QCCheckpointStatus,
+    StepStatus,
+    WorkflowExecutionStatus,
+    WorkflowStep,
+)
+
+__all__ = [
+    "BatchWorkflowExecution",
+    "WorkflowStep",
+    "QCCheckpoint",
+    "StepStatus",
+    "QCCheckpointStatus",
+    "WorkflowExecutionStatus",
+]

services/batch_execution/pipeline_triggers/__init__.py

@@ -0,0 +1,53 @@
+"""
+Pipeline Triggers Module
+
+Event-driven workflow re-evaluation system for phase 3.
+
+Components:
+- pipeline_trigger_engine: Event listener and trigger management
+- pipeline_parameter_adjuster: Variance analysis and parameter adjustment
+- re_evaluation_queue: Priority queue with deduplication
+- workflow_reevaluator: High-level orchestrator
+"""
+
+from services.batch_execution.pipeline_triggers.pipeline_parameter_adjuster import (
+    AdjustmentStrategy,
+    ParameterAdjustment,
+    PipelineParameterAdjuster,
+    WorkflowParameterSet,
+)
+from services.batch_execution.pipeline_triggers.pipeline_trigger_engine import (
+    PipelineTriggerEngine,
+    PipelineTriggerRecord,
+    TriggerThrottlePolicy,
+)
+from services.batch_execution.pipeline_triggers.re_evaluation_queue import (
+    ReEvaluationPriority,
+    ReEvaluationQueue,
+    ReEvaluationReason,
+    ReEvaluationRequest,
+)
+from services.batch_execution.pipeline_triggers.workflow_reevaluator import (
+    ReEvaluationMetrics,
+    WorkflowReevaluator,
+)
+
+__all__ = [
+    # Re-evaluation Queue
+    "ReEvaluationQueue",
+    "ReEvaluationRequest",
+    "ReEvaluationReason",
+    "ReEvaluationPriority",
+    # Parameter Adjuster
+    "PipelineParameterAdjuster",
+    "ParameterAdjustment",
+    "WorkflowParameterSet",
+    "AdjustmentStrategy",
+    # Trigger Engine
+    "PipelineTriggerEngine",
+    "PipelineTriggerRecord",
+    "TriggerThrottlePolicy",
+    # Workflow Re-evaluator
+    "WorkflowReevaluator",
+    "ReEvaluationMetrics",
+]