dojozero 0.3.0__tar.gz → 0.5.0__tar.gz

{dojozero-0.3.0 → dojozero-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dojozero
-Version: 0.3.0
+Version: 0.5.0
 Summary: A platform for running AI agents on realtime sport data and make predictions about game outcomes.
 Project-URL: Homepage, https://github.com/agentscope-ai/DojoZero
 Project-URL: Repository, https://github.com/agentscope-ai/DojoZero
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.11
-Requires-Dist: agentscope[gemini]>=1.0.14
+Requires-Dist: agentscope[gemini]<2,>=1.0.14
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: dashscope>=1.0.0
 Requires-Dist: fastapi>=0.128.0
@@ -32,6 +32,8 @@ Requires-Dist: pyyaml>=6.0
 Requires-Dist: tavily-python>=0.7.12
 Requires-Dist: uvicorn>=0.40.0
 Requires-Dist: xdk>=0.9.0
+Provides-Extra: agentid
+Requires-Dist: agent-id-service-sdk>=0.3.0; extra == 'agentid'
 Provides-Extra: alicloud
 Requires-Dist: alibabacloud-credentials>=1.0.0; extra == 'alicloud'
 Requires-Dist: aliyun-log-python-sdk; extra == 'alicloud'

{dojozero-0.3.0 → dojozero-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dojozero"
-version = "0.3.0"
+version = "0.5.0"
 description = "A platform for running AI agents on realtime sport data and make predictions about game outcomes."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -26,7 +26,7 @@ dependencies = [
     "PyYAML>=6.0",
     "pydantic>=2.12.4",
     "aiohttp>=3.9.0",
-    "agentscope[gemini]>=1.0.14",
+    "agentscope[gemini]>=1.0.14,<2",
     "py-clob-client>=0.1.0",
     "fastapi>=0.128.0",
     "uvicorn>=0.40.0",
@@ -61,3 +61,6 @@ alicloud = [
 redis = [
     "redis>=7.2.1",
 ]
+agentid = [
+    "agent-id-service-sdk>=0.3.0",
+]

{dojozero-0.3.0 → dojozero-0.5.0}/src/dojozero/agents/_config.py

@@ -122,8 +122,14 @@ def load_persona_config(config_path: str | Path) -> PersonaConfig:
         Parsed PersonaConfig dictionary
     """
     path = Path(config_path)
-    with path.open("r", encoding="utf-8") as f:
-        data: dict[str, Any] = yaml.safe_load(f)
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            data: dict[str, Any] = yaml.safe_load(f)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(
+            f"Persona config file not found: {path}. Check the persona_config_path "
+            "referenced by your agent or trial-source config."
+        ) from e
 
     return PersonaConfig(sys_prompt=data.get("sys_prompt", ""))
 
@@ -156,8 +162,14 @@ def load_llm_file_config(config_path: str | Path) -> LLMFileConfig:
         Parsed LLMFileConfig dictionary with llm as a list of LLMConfig
     """
     path = Path(config_path)
-    with path.open("r", encoding="utf-8") as f:
-        data: dict[str, Any] = yaml.safe_load(f)
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            data: dict[str, Any] = yaml.safe_load(f)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(
+            f"LLM config file not found: {path}. Check the llm_config_path "
+            "referenced by your agent or trial-source config."
+        ) from e
 
     llm_configs: list[LLMConfig] = []
 

{dojozero-0.3.0 → dojozero-0.5.0}/src/dojozero/arena_server/_cache.py

@@ -40,7 +40,21 @@ class CacheConfig:
     trials_limit: int = 500
 
     # Time range
-    trials_lookback_days: int = 90
+    trials_lookback_days: int = 365
+    # Per-league lookback override (in days). League name uppercase.
+    # Used to filter per-league cached views (leaderboard/games/stats/agent_actions).
+    # May exceed trials_lookback_days: the SLS fetch window auto-expands to
+    # max(trials_lookback_days, max(league_lookback_days.values())) in _sync, so a
+    # larger per-league window is still fully covered.
+    league_lookback_days: dict[str, int] = field(
+        default_factory=lambda: {"NBA": 90, "NFL": 365}
+    )
+
+    def get_league_lookback(self, league: str | None) -> int:
+        """Effective lookback (days) for a given league. Falls back to global."""
+        if league is None:
+            return self.trials_lookback_days
+        return self.league_lookback_days.get(league.upper(), self.trials_lookback_days)
 
     @classmethod
     def from_arena_config(cls, config: "ArenaServerConfig") -> "CacheConfig":
@@ -55,6 +69,7 @@ class CacheConfig:
             leaderboard_limit=config.query_limits.leaderboard_limit,
             trials_limit=config.cache.trials_limit,
             trials_lookback_days=config.cache.trials_lookback_days,
+            league_lookback_days=dict(config.cache.league_lookback_days),
         )
 
 
@@ -62,7 +77,7 @@ class CacheConfig:
 from dojozero.arena_server._config import ArenaServerConfig  # noqa: E402
 
 DEFAULT_CACHE_CONFIG = CacheConfig()
-CACHEABLE_LEAGUES: frozenset[str] = frozenset({"NBA", "NFL"})
+CACHEABLE_LEAGUES: frozenset[str] = frozenset({"NBA", "NFL", "WORLD_CUP"})
 LEADERBOARD_PERIODS: tuple[str, ...] = ("7d", "14d", "30d")
 
 
@@ -102,7 +117,7 @@ class LandingPageCache:
     - leaderboard: Agent rankings (global + per-league)
     - agent_actions: Recent agent actions (global + per-league)
 
-    Per-league caches are maintained for CACHEABLE_LEAGUES (NBA, NFL).
+    Per-league caches are maintained for CACHEABLE_LEAGUES.
 
     Note: No lock is needed because BackgroundRefresher is the single writer
     and Python's GIL ensures atomic reference assignments.

{dojozero-0.3.0 → dojozero-0.5.0}/src/dojozero/arena_server/_config.py

@@ -20,7 +20,12 @@ class CacheConfig(BaseModel):
 
     # Time range
     trials_lookback_days: int = Field(
-        default=90, description="Days to look back for trials"
+        default=365,
+        description="Days to look back for trials (global SLS fetch window; auto-expanded to cover any larger league_lookback_days)",
+    )
+    league_lookback_days: dict[str, int] = Field(
+        default_factory=lambda: {"NBA": 90, "NFL": 365},
+        description="Per-league lookback (days). Used to filter per-league cached views.",
     )
     trials_limit: int = Field(default=500, description="Max trials to fetch per query")
 

{dojozero-0.3.0 → dojozero-0.5.0}/src/dojozero/arena_server/_endpoints.py

@@ -237,7 +237,11 @@ def register_rest_endpoints(app: FastAPI) -> None:
             superbowl_game = next(
                 (g for g in all_games if SUPER_BOWL_GAME_ID in g.id), None
             )
-            if superbowl_game and superbowl_game not in live_games:
+            if (
+                superbowl_game
+                and superbowl_game.status == "live"
+                and superbowl_game not in live_games
+            ):
                 live_games = [superbowl_game] + list(live_games)
 
         # only for mock test
@@ -385,9 +389,13 @@ def register_rest_endpoints(app: FastAPI) -> None:
             default=None,
             description="Agent type filter: 'built_in' or 'external'.",
         ),
+        mode: str | None = Query(
+            default=None,
+            description="Leaderboard mode filter: 'market' or 'prediction'.",
+        ),
         sort_by: str = Query(
             default="winnings",
-            description="Sort field: 'winnings', 'win_rate', 'roi', 'total_bets'.",
+            description="Sort field: 'winnings', 'win_rate', 'roi', 'total_bets', 'sharpe', 'prediction_score', 'accuracy', 'total_predictions'.",
         ),
         sort_order: str = Query(
             default="desc",
@@ -413,6 +421,37 @@ def register_rest_endpoints(app: FastAPI) -> None:
                     "error": f"Invalid period '{period}'. Must be one of: {', '.join(sorted(valid_periods))}"
                 },
             )
+        valid_modes = {None, "market", "prediction"}
+        if mode not in valid_modes:
+            return JSONResponse(
+                status_code=400,
+                content={"error": "Invalid mode. Must be one of: market, prediction."},
+            )
+        valid_sort_by = {
+            "winnings",
+            "win_rate",
+            "roi",
+            "total_bets",
+            "sharpe",
+            "prediction_score",
+            "accuracy",
+            "total_predictions",
+        }
+        if sort_by not in valid_sort_by:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "error": f"Invalid sort_by '{sort_by}'. Must be one of: {', '.join(sorted(valid_sort_by))}"
+                },
+            )
+        valid_sort_orders = {"asc", "desc"}
+        if sort_order not in valid_sort_orders:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "error": f"Invalid sort_order '{sort_order}'. Must be one of: asc, desc"
+                },
+            )
 
         # All paths now read from pre-computed cache
         effective_period = period if period != "all" else None
@@ -437,16 +476,67 @@ def register_rest_endpoints(app: FastAPI) -> None:
         elif agent_type == "built_in":
             leaderboard = [e for e in leaderboard if not e.agent.is_external]
 
-        # 2. Sort (cached path is already sorted by winnings desc; re-sort only when needed)
-        if sort_by != "winnings" or sort_order != "desc":
+        # Mode split: agents are shared across sports, so an agent can have both
+        # betting PnL (market) and a prediction score. Filter by *activity* rather
+        # than mutual exclusion so a top bettor that also predicted still shows on
+        # the market board (with winnings) and on the prediction board (with score).
+        if mode == "prediction":
+            leaderboard = [e for e in leaderboard if e.prediction_score is not None]
+        elif mode == "market":
+            leaderboard = [
+                e for e in leaderboard if e.total_bets > 0 or e.winnings != 0
+            ]
+
+        # 2. Sort (prediction-mode rows use ScoringSys metrics, not betting PnL)
+        has_prediction_data = any(e.prediction_score is not None for e in leaderboard)
+        is_world_cup_view = league is not None and league.upper() == "WORLD_CUP"
+        # mode="market" is an explicit betting view: never remap its sort to
+        # prediction_score, even for World Cup. Only an unspecified mode falls
+        # back to the league's default (prediction) view.
+        is_prediction_view = mode == "prediction" or (
+            is_world_cup_view and mode is None
+        )
+        effective_sort_by = sort_by
+        if (
+            is_prediction_view
+            and has_prediction_data
+            and sort_by
+            in (
+                "winnings",
+                "win_rate",
+                "roi",
+                "total_bets",
+                "sharpe",
+            )
+        ):
+            effective_sort_by = "prediction_score"
+
+        if (
+            sort_by != "winnings"
+            or sort_order != "desc"
+            or effective_sort_by != sort_by
+        ):
             sort_key_map = {
                 "winnings": lambda x: x.winnings,
                 "win_rate": lambda x: x.win_rate,
                 "roi": lambda x: x.roi,
                 "sharpe": lambda x: x.sharpe,
                 "total_bets": lambda x: x.total_bets,
+                "prediction_score": lambda x: (
+                    x.prediction_score
+                    if x.prediction_score is not None
+                    else -float("inf")
+                ),
+                "accuracy": lambda x: (
+                    x.accuracy if x.accuracy is not None else -float("inf")
+                ),
+                "total_predictions": lambda x: (
+                    x.total_predictions
+                    if x.total_predictions is not None
+                    else -float("inf")
+                ),
             }
-            key_fn = sort_key_map.get(sort_by, sort_key_map["winnings"])
+            key_fn = sort_key_map.get(effective_sort_by, sort_key_map["winnings"])
             leaderboard = sorted(leaderboard, key=key_fn, reverse=(sort_order != "asc"))
 
         # 3. Limit

{dojozero-0.3.0 → dojozero-0.5.0}/src/dojozero/arena_server/_models.py

@@ -42,6 +42,7 @@ class AgentProfileStats(BaseModel):
     win_rate: float = Field(default=0.0, serialization_alias="winRate")
     total_bets: int = Field(default=0, serialization_alias="totalBets")
     roi: float = 0.0
+    sharpe: float = 0.0
 
 
 class AgentProfileResponse(BaseModel):
@@ -75,11 +76,20 @@ class StatsResponse(BaseModel):
 
     model_config = ConfigDict(frozen=True, populate_by_name=True)
 
+    # serialization_alias matches the field name; kept for consistency with the
+    # rest of the model (every field declares its wire name) and rename-safety.
+    mode: Literal["betting", "prediction", "mixed"] = Field(
+        default="betting", serialization_alias="mode"
+    )
     games_played: int = Field(default=0, serialization_alias="gamesPlayed")
     live_now: int = Field(default=0, serialization_alias="liveNow")
     wagered_today: int = Field(default=0, serialization_alias="wageredToday")
     total_agents: int = Field(default=0, serialization_alias="totalAgents")
     bet_counts: int = Field(default=0, serialization_alias="betCounts")
+    prediction_count: int = Field(default=0, serialization_alias="predictionCount")
+    prediction_points: float = Field(
+        default=0.0, serialization_alias="predictionPoints"
+    )
 
 
 class GameCardData(BaseModel):
@@ -89,6 +99,11 @@ class GameCardData(BaseModel):
 
     id: str
     league: str = ""
+    # Contest type for sports run as multiple trials per match (e.g. World Cup
+    # runs both a window-pool "prediction" trial and a moneyline "betting"
+    # trial). Empty when unknown / not applicable. Used by the landing dedup to
+    # prefer the prediction trial. See _detect_contest_kind.
+    contest_kind: str = Field(default="", serialization_alias="contestKind")
     home_team: TeamIdentity = Field(
         default_factory=TeamIdentity,
         serialization_alias="homeTeam",

{dojozero-0.3.0 → dojozero-0.5.0}/src/dojozero/arena_server/_server.py

@@ -29,7 +29,7 @@ Filtering:
 
     Supported endpoints: /api/landing, /api/stats, /api/games, /api/leaderboard, /api/agent-actions
 
-    Per-league results are cached separately for leagues in CACHEABLE_LEAGUES (NBA, NFL).
+    Per-league results are cached separately for leagues in CACHEABLE_LEAGUES.
     To add a new league, update CACHEABLE_LEAGUES in the code.
 
 Configuration:
@@ -90,6 +90,7 @@ from dojozero.arena_server._utils import (
     _compute_leaderboard,
     _compute_leaderboard_from_spans,
     _load_replay_data,
+    ARENA_RENDERED_OPERATIONS,
     TRIAL_INFO_OPERATION_NAMES,
     trial_id_for_span_grouping,
 )
@@ -789,7 +790,11 @@ class BackgroundRefresher:
             tid: str, span_start: datetime | None
         ) -> tuple[str, list[SpanData]]:
             async with sem:
-                spans = await self.trace_reader.get_spans(tid, start_time=span_start)
+                spans = await self.trace_reader.get_spans(
+                    tid,
+                    start_time=span_start,
+                    operation_names=ARENA_RENDERED_OPERATIONS,
+                )
                 return tid, spans
 
         if is_initial or self._last_span_fetch_time is None:
@@ -1417,7 +1422,9 @@ class BackgroundRefresher:
 
         # Fallback to SLS (slow path)
         if not spans:
-            spans = await self.trace_reader.get_spans(trial_id)
+            spans = await self.trace_reader.get_spans(
+                trial_id, operation_names=ARENA_RENDERED_OPERATIONS
+            )
 
         existing = self.cache.get_trial_details(trial_id)