Enable .pt bot runtime and reduce UI polling load

Dieg0Code · Dieg0Code · commit 44ca9e5fe8f8 · 2026-03-02T03:08:06.000-03:00
diff --git a/Dockerfile b/Dockerfile
@@ -28,6 +28,9 @@ COPY pyproject.toml uv.lock README.md ./
 # Install only API runtime dependencies; the training stack (torch/cuda) is not
 # needed for the web service and was causing Railway build timeouts.
 RUN uv sync --frozen --no-install-project --only-group api
+# The API can run model bots from `.pt` checkpoints; install CPU-only torch in
+# the API venv so Railway does not need CUDA runtimes.
+RUN uv pip install --python /app/.venv/bin/python --index-url https://download.pytorch.org/whl/cpu torch
 
 
 FROM python:3.11-slim AS runtime
diff --git a/scripts/bootstrap_model_bot.py b/scripts/bootstrap_model_bot.py
@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+
+from sqlmodel import col, select
+
+# Permite ejecutar el script desde la raiz del repo.
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Crea/actualiza una cuenta bot de modelo y la deja visible en ladder.",
+    )
+    parser.add_argument("--username", default="ub_bogonet_v0")
+    parser.add_argument("--model-version-name", default="ub_bogonet_v0_iter039")
+    parser.add_argument("--hf-repo-id", default="dieg0code/ataxx-zero")
+    parser.add_argument("--hf-revision", default="main")
+    parser.add_argument("--checkpoint-uri", default="hf://dieg0code/ataxx-zero/model_iter_039.pt")
+    parser.add_argument("--onnx-uri", default="")
+    parser.add_argument("--model-mode", choices=["fast", "strong"], default="fast")
+    parser.add_argument("--activate-version", action="store_true")
+    return parser.parse_args()
+
+
+async def _ensure_model_bot(args: argparse.Namespace) -> None:
+    from api.db.enums import AgentType, BotKind
+    from api.db.models import BotProfile, ModelVersion, User
+    from api.db.session import get_engine, get_sessionmaker
+    from api.modules.ranking.repository import RankingRepository
+    from api.modules.ranking.service import RankingService
+
+    sessionmaker = get_sessionmaker()
+    async with sessionmaker() as session:
+        version_stmt = select(ModelVersion).where(
+            col(ModelVersion.name) == args.model_version_name
+        )
+        version = (await session.execute(version_stmt)).scalars().first()
+        if version is None:
+            version = ModelVersion(
+                name=args.model_version_name,
+                hf_repo_id=args.hf_repo_id,
+                hf_revision=args.hf_revision,
+                checkpoint_uri=args.checkpoint_uri,
+                onnx_uri=(args.onnx_uri or None),
+                is_active=bool(args.activate_version),
+                notes="Bot bootstrap script.",
+            )
+            session.add(version)
+            await session.commit()
+            await session.refresh(version)
+        else:
+            version.hf_repo_id = args.hf_repo_id
+            version.hf_revision = args.hf_revision
+            version.checkpoint_uri = args.checkpoint_uri
+            version.onnx_uri = args.onnx_uri or None
+            if args.activate_version:
+                version.is_active = True
+            session.add(version)
+            await session.commit()
+            await session.refresh(version)
+
+        if args.activate_version:
+            await session.execute(
+                # Keep one global active version when requested explicitly.
+                ModelVersion.__table__.update()
+                .where(col(ModelVersion.id) != version.id)
+                .values(is_active=False)
+            )
+            await session.execute(
+                ModelVersion.__table__.update()
+                .where(col(ModelVersion.id) == version.id)
+                .values(is_active=True)
+            )
+            await session.commit()
+
+        user_stmt = select(User).where(col(User.username) == args.username)
+        user = (await session.execute(user_stmt)).scalars().first()
+        if user is None:
+            user = User(
+                username=args.username,
+                email=f"{args.username}@bots.local",
+                is_active=True,
+                is_admin=False,
+                is_bot=True,
+                bot_kind=BotKind.MODEL,
+                is_hidden_bot=False,
+                model_version_id=version.id,
+            )
+            session.add(user)
+            await session.commit()
+            await session.refresh(user)
+
+        user.is_active = True
+        user.is_bot = True
+        user.is_hidden_bot = False
+        user.bot_kind = BotKind.MODEL
+        user.model_version_id = version.id
+        session.add(user)
+        await session.commit()
+        await session.refresh(user)
+
+        profile_stmt = select(BotProfile).where(col(BotProfile.user_id) == user.id)
+        profile = (await session.execute(profile_stmt)).scalars().first()
+        if profile is None:
+            profile = BotProfile(
+                user_id=user.id,
+                agent_type=AgentType.MODEL,
+                model_mode=args.model_mode,
+                enabled=True,
+            )
+        profile.agent_type = AgentType.MODEL
+        profile.model_mode = args.model_mode
+        profile.heuristic_level = None
+        profile.enabled = True
+        session.add(profile)
+        await session.commit()
+        await session.refresh(profile)
+
+        ranking_service = RankingService(ranking_repository=RankingRepository(session=session))
+        season = await ranking_service.get_active_season()
+        if season is None:
+            raise RuntimeError("No active season found. Run scripts/bootstrap_active_season.py first.")
+        rating = await ranking_service.get_or_create_rating(user.id, season.id)
+        entries = await ranking_service.recompute_leaderboard(season_id=season.id, limit=500)
+        rank = next((entry.rank for entry in entries if entry.user_id == user.id), None)
+
+        print("Model bot ready:")
+        print(f"  user_id={user.id}")
+        print(f"  username={user.username}")
+        print(f"  model_version_id={version.id}")
+        print(f"  checkpoint_uri={version.checkpoint_uri}")
+        print(f"  model_mode={profile.model_mode}")
+        print(f"  season_id={season.id}")
+        print(f"  rating={rating.rating:.1f}")
+        print(f"  rank={rank}")
+
+    await get_engine().dispose()
+
+
+def main() -> None:
+    args = _parse_args()
+    asyncio.run(_ensure_model_bot(args))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/api/modules/matches/router.py b/src/api/modules/matches/router.py
@@ -233,7 +233,8 @@ async def invitations_ws(
                 }
             )
             try:
-                await asyncio.wait_for(websocket.receive_text(), timeout=1.0)
+                # Lower polling pressure on DB while still keeping invitation UI responsive.
+                await asyncio.wait_for(websocket.receive_text(), timeout=2.5)
             except (TimeoutError, asyncio.TimeoutError):
                 continue
     except (WebSocketDisconnect, asyncio.TimeoutError):
diff --git a/web/src/features/matches/useInvitations.ts b/web/src/features/matches/useInvitations.ts
@@ -36,21 +36,26 @@ export function useInvitations({
   const queryClient = useQueryClient();
   const [liveInvitations, setLiveInvitations] = useState<HumanInvitation[] | null>(null);
   const [actionLoadingId, setActionLoadingId] = useState<string | null>(null);
+  const [socketHealthy, setSocketHealthy] = useState(false);
 
   const invitationsQuery = useQuery({
     queryKey: ["invitations", scope, accessToken],
     queryFn: () => fetchIncomingInvitations(accessToken!, 12, 0),
     enabled: enabled && includeInitialFetch && accessToken !== null,
+    // Poll only while websocket fallback is degraded; this keeps UI fresh
+    // without hammering the API every few seconds during healthy socket sessions.
     refetchInterval:
-      enabled && includeInitialFetch && fallbackPollingMs > 0
+      enabled && includeInitialFetch && fallbackPollingMs > 0 && !socketHealthy
         ? fallbackPollingMs
         : false,
     refetchIntervalInBackground: true,
+    staleTime: 8_000,
   });
 
   useEffect(() => {
     if (!enabled || accessToken === null) {
       setLiveInvitations(null);
+      setSocketHealthy(false);
       return;
     }
     let cancelled = false;
@@ -80,11 +85,13 @@ export function useInvitations({
       if (event.type !== "invitations.status") {
         return;
       }
+      setSocketHealthy(true);
       const pendingItems = event.payload.items.filter((item) => item.status === "pending");
       setLiveInvitations(pendingItems);
     };
 
     const onSocketFailure = (): void => {
+      setSocketHealthy(false);
       setLiveInvitations(null);
       if (includeInitialFetch) {
         void queryClient.invalidateQueries({ queryKey: ["invitations", scope, accessToken] });
@@ -97,6 +104,9 @@ export function useInvitations({
         return;
       }
       socket = openInvitationsSocket(accessToken, onEvent);
+      socket.onopen = () => {
+        setSocketHealthy(true);
+      };
       socket.onerror = () => {
         onSocketFailure();
       };
diff --git a/web/src/pages/match/MatchPage.tsx b/web/src/pages/match/MatchPage.tsx
@@ -62,6 +62,8 @@ const AI_THINK_DELAY_MS = 460;
 const AI_PREVIEW_MS = 420;
 const INFECTION_STEP_MS = 90;
 const INFECTION_BURST_MS = 420;
+const OUTGOING_INVITE_POLL_MS = 2500;
+const UI_TICK_MS = 120;
 const INTRO_COUNTDOWN_START = 3;
 const HOVER_SFX_MIN_GAP_MS = 120;
 const P2_MOVE_SFX_MIN_GAP_MS = 70;
@@ -1095,7 +1097,7 @@ export function MatchPage(): JSX.Element {
           // Keep polling; temporary network errors should not close invitation flow.
         }
       })();
-    }, 1200);
+    }, OUTGOING_INVITE_POLL_MS);
     return () => {
       cancelled = true;
       window.clearInterval(intervalId);
@@ -1188,10 +1190,19 @@ export function MatchPage(): JSX.Element {
     }
   }, [selectedP2Bot]);
 
+  const needsUiTicker =
+    matchStarted ||
+    previewMove !== null ||
+    infectionBursts.length > 0 ||
+    Object.keys(infectionMask).length > 0;
+
   useEffect(() => {
-    const interval = window.setInterval(() => setNowMs(Date.now()), 40);
+    if (!needsUiTicker) {
+      return;
+    }
+    const interval = window.setInterval(() => setNowMs(Date.now()), UI_TICK_MS);
     return () => window.clearInterval(interval);
-  }, []);
+  }, [needsUiTicker]);
 
   useEffect(() => {
     if (!matchStarted || !showIntro) {
diff --git a/web/src/widgets/layout/AppShell.tsx b/web/src/widgets/layout/AppShell.tsx
@@ -124,7 +124,7 @@ export function AppShell({ children, onNavigateAttempt, onLogoutAttempt }: AppSh
     enabled: isAuthenticated,
     includeInitialFetch: true,
     scope: "appshell",
-    fallbackPollingMs: 3000,
+    fallbackPollingMs: 8000,
   });
   const incomingInvitations = pendingInvitations.length;
   const sortedInvitations = useMemo(

Original file line number	Diff line number	Diff line change
`@@ -233,7 +233,8 @@ async def invitations_ws(`
`233`	`233`	`}`
`234`	`234`	`)`
`235`	`235`	`try:`
`236`		`- await asyncio.wait_for(websocket.receive_text(), timeout=1.0)`
	`236`	`+ # Lower polling pressure on DB while still keeping invitation UI responsive.`
	`237`	`+ await asyncio.wait_for(websocket.receive_text(), timeout=2.5)`
`237`	`238`	`except (TimeoutError, asyncio.TimeoutError):`
`238`	`239`	`continue`
`239`	`240`	`except (WebSocketDisconnect, asyncio.TimeoutError):`