aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/packages/aria_tools/financial/__init__.py

@@ -0,0 +1,5 @@
+"""Shared financial source helpers.
+
+The old skill wrappers were demo invocations without production data contracts.
+Financial analysis runs through the configured data router and financial-service.
+"""

aria_code/packages/aria_tools/financial/_paths.py

@@ -0,0 +1,92 @@
+"""查找已安装 skills 并桥接显式配置的 Arthera 子包。
+
+skill 那边其实早就有一套正规的发现顺序 —— packages/aria_skills/loader.py
+的 default_skill_roots()（ARIA_SKILLS_PATH 环境变量 → 同级 aria-skills
+checkout → ~/.arthera/skills → ~/.claude/skills → …）。这里直接复用它，
+而不是再写第二套查找逻辑，免得两处顺序不一致时出现"CLI 能发现这个 skill、
+工具却找不到它的脚本"。
+
+Arthera 子包是私有仓库的东西，公开仓库无从假设它在哪；仅支持显式的
+ARTHERA_ROOT / ARTHERA_PATH 设置，不隐式发现相邻源码目录。
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from aria_code.packages.aria_core.paths import aria_home
+
+__all__ = ["find_skill_script", "missing_script_message", "ensure_arthera_root"]
+
+
+def _skill_roots() -> list[Path]:
+    """优先复用 skill loader 的发现顺序；它不可用时退化为等价的最小实现。"""
+    try:
+        from packages.aria_skills.loader import default_skill_roots
+
+        return [Path(p) for p in default_skill_roots()]
+    except Exception:
+        roots: list[Path] = []
+        configured = os.getenv("ARIA_SKILLS_PATH", "")
+        roots.extend(
+            Path(item).expanduser() for item in configured.split(os.pathsep) if item.strip()
+        )
+        repository = Path(__file__).resolve().parents[3]
+        roots.extend([
+            repository.parent / "aria-skills" / "skills",
+            aria_home() / "skills",
+            Path.home() / ".aria" / "skills",
+            Path.home() / ".claude" / "skills",
+        ])
+        return roots
+
+
+def find_skill_script(skill_name: str, script_name: str) -> Path | None:
+    """返回 <某个 skill 根>/<skill_name>/scripts/<script_name>，找不到返回 None。
+
+    调用方负责把 None 变成对用户有意义的提示——这里不抛异常，因为"本机没装
+    这个 skill 目录"是完全正常的部署形态，不是错误。
+    """
+    for root in _skill_roots():
+        candidate = root / skill_name / "scripts" / script_name
+        try:
+            if candidate.is_file():
+                return candidate
+        except OSError:
+            continue
+    return None
+
+
+def missing_script_message(skill_name: str, script_name: str) -> str:
+    """脚本缺失时给出可操作的提示，而不是打印一条别人机器上不存在的路径。"""
+    return (
+        f"Error: 找不到 {skill_name}/scripts/{script_name}。"
+        " 请获取 aria-skills 目录，并用 ARIA_SKILLS_PATH 指向其中的 skills/，"
+        "或把它放在 aria-code 的同级目录下。"
+    )
+
+
+def ensure_arthera_root() -> bool:
+    """把 Arthera 仓库根目录加进 sys.path，让 ``packages.*`` 可导入。返回是否找到。
+
+    Arthera 是私有仓库，公开仓库不该假设它
+    在某个写死的绝对路径上。这里认的是 ``ARTHERA_ROOT``（doctor.py 与
+    backtest_cmds.py 已经在用的同一个变量），不隐式发现旁边的源码目录。
+    """
+    candidates: list[Path] = []
+    for var in ("ARTHERA_ROOT", "ARTHERA_PATH"):
+        configured = os.getenv(var, "")
+        if configured.strip():
+            candidates.append(Path(configured).expanduser())
+
+    for candidate in candidates:
+        try:
+            if candidate.is_dir():
+                path_str = str(candidate)
+                if path_str not in sys.path:
+                    sys.path.append(path_str)
+                return True
+        except OSError:
+            continue
+    return False

aria_code/packages/aria_tools/registry.py

@@ -0,0 +1,129 @@
+"""Tool registry facade over Aria Code's legacy LOCAL_TOOLS shape."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional
+
+from aria_code.packages.aria_core import CapabilityManifest, PermissionLevel, ServiceKind
+
+
+Handler = Callable[[dict], dict]
+
+
+_PERMISSION_BY_TOOL = {
+    "read_file": [PermissionLevel.READ_ONLY],
+    "list_files": [PermissionLevel.READ_ONLY],
+    "search_code": [PermissionLevel.READ_ONLY],
+    "glob": [PermissionLevel.READ_ONLY],
+    "write_file": [PermissionLevel.WORKSPACE_WRITE],
+    "edit_file": [PermissionLevel.WORKSPACE_WRITE],
+    "notebook_edit": [PermissionLevel.WORKSPACE_WRITE],
+    "run_command": [PermissionLevel.WORKSPACE_WRITE],
+    "process": [PermissionLevel.WORKSPACE_WRITE],
+    "web_fetch": [PermissionLevel.NETWORK],
+    "github": [PermissionLevel.NETWORK],
+    "get_market_data": [PermissionLevel.NETWORK],
+    "broker_query": [PermissionLevel.BROKER_READ],
+    "broker_order": [PermissionLevel.BROKER_TRADE],
+}
+
+
+@dataclass(frozen=True)
+class ToolSpec:
+    name: str
+    handler: Optional[Handler]
+    description: str
+    schema: Dict[str, Any] = field(default_factory=dict)
+    permissions: List[PermissionLevel] = field(default_factory=list)
+    capabilities: List[str] = field(default_factory=list)
+
+    def manifest(self) -> CapabilityManifest:
+        return CapabilityManifest(
+            name=self.name,
+            kind=ServiceKind.TOOL,
+            description=self.description,
+            capabilities=self.capabilities,
+            permissions=self.permissions,
+            input_schema=self.schema,
+            tags=["tool"],
+        )
+
+
+class ToolRegistry:
+    """Small typed registry that can wrap existing dict-based tools."""
+
+    def __init__(self) -> None:
+        self._tools: Dict[str, ToolSpec] = {}
+
+    def register(self, spec: ToolSpec, *, overwrite: bool = False) -> None:
+        if spec.name in self._tools and not overwrite:
+            raise ValueError(f"tool already registered: {spec.name}")
+        self._tools[spec.name] = spec
+
+    def get(self, name: str) -> Optional[ToolSpec]:
+        return self._tools.get(name)
+
+    def list(self) -> List[ToolSpec]:
+        return [self._tools[name] for name in sorted(self._tools)]
+
+    def manifests(self) -> List[CapabilityManifest]:
+        return [tool.manifest() for tool in self.list()]
+
+    def legacy_tools(self) -> Dict[str, tuple]:
+        return {
+            name: (spec.handler, spec.description)
+            for name, spec in self._tools.items()
+            if spec.handler is not None
+        }
+
+
+def _schema_by_name(schemas: Iterable[dict]) -> Dict[str, dict]:
+    out: Dict[str, dict] = {}
+    for schema in schemas or []:
+        fn = schema.get("function") or {}
+        name = fn.get("name")
+        if name:
+            out[name] = fn.get("parameters") or {}
+    return out
+
+
+def _capabilities_for_tool(name: str) -> List[str]:
+    if name.startswith("broker_"):
+        return ["broker"]
+    if name in ("get_market_data",) or "market" in name or "quote" in name:
+        return ["market.data"]
+    if name in ("read_file", "list_files", "search_code", "glob"):
+        return ["workspace.read"]
+    if name in ("write_file", "edit_file", "notebook_edit"):
+        return ["workspace.write"]
+    if name in ("run_command", "process"):
+        return ["shell"]
+    if name in ("web_fetch", "github"):
+        return ["network"]
+    return ["tool"]
+
+
+def build_registry_from_legacy(
+    tools: Mapping[str, tuple],
+    schemas: Iterable[dict] = (),
+) -> ToolRegistry:
+    """Create a typed registry from ``LOCAL_TOOLS`` and tool schemas."""
+
+    registry = ToolRegistry()
+    schema_map = _schema_by_name(schemas)
+    for name, value in tools.items():
+        handler = value[0] if value else None
+        description = value[1] if len(value) > 1 else ""
+        registry.register(
+            ToolSpec(
+                name=name,
+                handler=handler,
+                description=description,
+                schema=schema_map.get(name, {}),
+                permissions=_PERMISSION_BY_TOOL.get(name, [PermissionLevel.READ_ONLY]),
+                capabilities=_capabilities_for_tool(name),
+            ),
+            overwrite=True,
+        )
+    return registry

aria_code/packages/quant_engine/__init__.py

@@ -0,0 +1,33 @@
+"""quant_engine — vendored commodity quant modules (sports + stochastic).
+
+Elo/Dixon-Coles football prediction and Black-Scholes/Monte-Carlo/Kelly
+options+derivatives math. Proprietary factor/ML/strategy engines stay in the
+private Arthera platform.
+
+Open-core boundary: callers MUST go through ``is_available()`` and degrade
+gracefully when it returns False. Today the source is bundled, so it is always
+available — but routing every use through this boundary means the day the engine
+is split into a separate compiled (.so) wheel, the free shell keeps working with
+no caller changes (see tools/build_quant_engine.py, CLOSING_SOURCE.md).
+"""
+
+from importlib.util import find_spec
+
+# Compiled/private engine distributions may retain only this public stub.
+# Absence of the optional extension helper must not prevent is_available().
+try:
+    from ._namespace import extend as _extend_namespace
+except ImportError:
+    pass
+else:
+    _extend_namespace(__path__, "")
+
+__version__ = "1.0.0"
+
+
+def is_available() -> bool:
+    """True if the quant engine (bundled source or compiled wheel) can be imported."""
+    try:
+        return find_spec("aria_code.packages.quant_engine.stochastic") is not None
+    except Exception:
+        return False

aria_code/packages/quant_engine/_namespace.py

@@ -0,0 +1,24 @@
+"""Explicit legacy backend opt-in; never search a developer's filesystem.
+
+Standalone financial-service over MCP is the normal integration. Existing
+private integrations may deliberately set ARTHERA_ROOT until their public API
+cutover. Bundled modules keep precedence over that configured source.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import List
+
+
+def extend(package_path: List[str], subpackage: str) -> None:
+    configured = os.getenv("ARTHERA_ROOT", "").strip()
+    if not configured:
+        return
+    candidate = Path(configured).expanduser() / "packages" / "quant_engine" / subpackage
+    try:
+        if candidate.is_dir() and str(candidate) not in package_path:
+            package_path.append(str(candidate))
+    except OSError:
+        return

aria_code/packages/quant_engine/backtest/__init__.py

@@ -0,0 +1,10 @@
+"""Backtest engine for evaluating AI trading signals."""
+
+from .core import Order, Position, Portfolio
+from .engine import BacktestEngine
+
+__all__ = ["Order", "Position", "Portfolio", "BacktestEngine"]
+
+# Optional explicit backend modules never override this distribution.
+from .._namespace import extend as _extend_namespace
+_extend_namespace(__path__, "backtest")

aria_code/packages/quant_engine/backtest/core.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+from datetime import datetime
+
+@dataclass
+class Order:
+    symbol: str
+    quantity: float
+    price: float
+    order_type: str = "MARKET"
+    direction: str = "BUY"  # BUY or SELL
+    status: str = "PENDING"
+    timestamp: Optional[datetime] = None
+
+@dataclass
+class Position:
+    symbol: str
+    quantity: float = 0.0
+    avg_price: float = 0.0
+
+    @property
+    def market_value(self, current_price: float) -> float:
+        return self.quantity * current_price
+
+    def update(self, quantity: float, price: float, is_buy: bool):
+        if is_buy:
+            total_cost = (self.quantity * self.avg_price) + (quantity * price)
+            self.quantity += quantity
+            self.avg_price = total_cost / self.quantity if self.quantity > 0 else 0
+        else:
+            self.quantity -= quantity
+            if self.quantity <= 0:
+                self.avg_price = 0.0
+                self.quantity = 0.0
+
+class Portfolio:
+    def __init__(self, initial_cash: float = 100000.0):
+        self.initial_cash = initial_cash
+        self.cash = initial_cash
+        self.positions: Dict[str, Position] = {}
+        self.history: List[Dict] = []
+
+    def get_position(self, symbol: str) -> Position:
+        if symbol not in self.positions:
+            self.positions[symbol] = Position(symbol=symbol)
+        return self.positions[symbol]
+
+    def total_value(self, current_prices: Dict[str, float]) -> float:
+        pos_value = sum(
+            pos.quantity * current_prices.get(sym, pos.avg_price)
+            for sym, pos in self.positions.items()
+        )
+        return self.cash + pos_value

aria_code/packages/quant_engine/backtest/engine.py

@@ -0,0 +1,102 @@
+from typing import List, Dict, Any
+import pandas as pd
+from .core import Portfolio, Order
+
+class BacktestEngine:
+    """Minimal Event-Driven Backtest Engine for Agent Signals"""
+
+    def __init__(self, initial_cash: float = 100000.0):
+        self.portfolio = Portfolio(initial_cash=initial_cash)
+        self.orders: List[Order] = []
+
+    def run_signals(self, price_data: pd.DataFrame, signals: List[Dict[str, Any]]):
+        """
+        Run backtest based on daily prices and agent signals.
+        price_data expects index to be datetime, with 'close' column.
+        signals expects format: [{'date': 'YYYY-MM-DD', 'signal': 'BUY', 'confidence': 0.8, 'symbol': 'AAPL'}]
+        """
+        # Convert signals to a dictionary indexed by date for O(1) lookup
+        signal_dict = {}
+        for s in signals:
+            try:
+                date_str = pd.to_datetime(s['date']).strftime('%Y-%m-%d')
+                signal_dict[date_str] = s
+            except (ValueError, TypeError, KeyError):
+                # 裸 except 会连 KeyboardInterrupt / SystemExit 一起吞掉——
+                # 循环里跑着时用户按 Ctrl+C 会被静默忽略。这里真正要容忍的
+                # 只是"某条信号的日期字段解析不了"，收窄到具体异常。
+                pass
+
+        equity_curve = []
+
+        for date, row in price_data.iterrows():
+            current_price = float(row['close'])
+            date_str = date.strftime('%Y-%m-%d')
+            symbol = "UNKNOWN" # Simplification for single-asset backtest for now
+
+            # Check for signals on this date
+            if date_str in signal_dict:
+                sig = signal_dict[date_str]
+                symbol = sig.get('symbol', 'UNKNOWN')
+                action = sig.get('signal', 'HOLD').upper()
+                confidence = float(sig.get('confidence', 0.5))
+
+                if action == 'BUY':
+                    # Allocate portion of cash based on confidence
+                    target_investment = self.portfolio.cash * confidence
+                    qty = int(target_investment / current_price)
+                    if qty > 0:
+                        cost = qty * current_price
+                        self.portfolio.cash -= cost
+                        pos = self.portfolio.get_position(symbol)
+                        pos.update(qty, current_price, True)
+                        self.orders.append(Order(symbol, qty, current_price, direction="BUY", status="FILLED", timestamp=date))
+
+                elif action in ['SELL', 'REDUCE']:
+                    pos = self.portfolio.get_position(symbol)
+                    if pos.quantity > 0:
+                        # Sell portion based on confidence
+                        sell_qty = int(pos.quantity * confidence)
+                        if sell_qty > 0:
+                            proceeds = sell_qty * current_price
+                            self.portfolio.cash += proceeds
+                            pos.update(sell_qty, current_price, False)
+                            self.orders.append(Order(symbol, sell_qty, current_price, direction="SELL", status="FILLED", timestamp=date))
+
+            # Record daily equity
+            total_val = self.portfolio.total_value({symbol: current_price})
+            equity_curve.append({
+                'date': date,
+                'total_value': total_val,
+                'cash': self.portfolio.cash
+            })
+
+        return pd.DataFrame(equity_curve).set_index('date')
+
+    def calculate_metrics(self, equity_df: pd.DataFrame) -> Dict[str, float]:
+        if equity_df.empty:
+            return {}
+
+        returns = equity_df['total_value'].pct_change().dropna()
+        total_return = (equity_df['total_value'].iloc[-1] / self.portfolio.initial_cash) - 1.0
+
+        # Periods a year from the equity curve's own dates; 252 when it has none.
+        from aria_code.domain import performance_stats as stats
+
+        periods = stats.periods_per_year_from_dates(
+            len(returns), equity_df.index[0], equity_df.index[-1]
+        ) or float(stats.FALLBACK_PERIODS_PER_YEAR)
+        ann_vol = returns.std() * (periods ** 0.5) if not returns.empty else 0.0
+        sharpe = (returns.mean() * periods) / ann_vol if ann_vol > 0 else 0.0
+
+        cum_ret = (1 + returns).cumprod()
+        peak = cum_ret.cummax()
+        drawdown = (cum_ret - peak) / peak
+        max_dd = drawdown.min()
+
+        return {
+            "total_return_pct": round(total_return * 100, 2),
+            "annualized_volatility_pct": round(ann_vol * 100, 2),
+            "sharpe_ratio": round(sharpe, 2),
+            "max_drawdown_pct": round(max_dd * 100, 2) if not pd.isna(max_dd) else 0.0
+        }

aria_code/packages/quant_engine/portfolio/__init__.py

@@ -0,0 +1,9 @@
+"""Portfolio optimization engine."""
+
+from .optimizer import PortfolioOptimizer
+
+__all__ = ["PortfolioOptimizer"]
+
+# Optional explicit backend modules never override this distribution.
+from .._namespace import extend as _extend_namespace
+_extend_namespace(__path__, "portfolio")

aria_code/packages/quant_engine/portfolio/optimizer.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pandas as pd
+from scipy.optimize import minimize
+from typing import Dict, List, Tuple
+
+class PortfolioOptimizer:
+    """Quantitative Portfolio Optimization Engine"""
+
+    def __init__(self, risk_free_rate: float = 0.02):
+        self.risk_free_rate = risk_free_rate
+
+    def _get_returns_stats(self, prices_df: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
+        returns = prices_df.pct_change().dropna()
+        mean_returns = returns.mean().values * 252
+        cov_matrix = returns.cov().values * 252
+        return mean_returns, cov_matrix
+
+    def portfolio_performance(self, weights: np.ndarray, mean_returns: np.ndarray, cov_matrix: np.ndarray) -> Tuple[float, float]:
+        returns = np.sum(mean_returns * weights)
+        std = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
+        return returns, std
+
+    def min_variance(self, prices_df: pd.DataFrame) -> Dict[str, float]:
+        """Minimize portfolio variance"""
+        symbols = prices_df.columns.tolist()
+        num_assets = len(symbols)
+        _, cov_matrix = self._get_returns_stats(prices_df)
+
+        args = (cov_matrix,)
+        def portfolio_volatility(weights, cov):
+            return np.sqrt(np.dot(weights.T, np.dot(cov, weights)))
+
+        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        bounds = tuple((0.0, 1.0) for asset in range(num_assets))
+        initial_guess = num_assets * [1. / num_assets,]
+
+        result = minimize(portfolio_volatility, initial_guess, args=args,
+                          method='SLSQP', bounds=bounds, constraints=constraints)
+
+        return {sym: round(weight, 4) for sym, weight in zip(symbols, result.x)}
+
+    def max_sharpe(self, prices_df: pd.DataFrame) -> Dict[str, float]:
+        """Maximize Sharpe Ratio"""
+        symbols = prices_df.columns.tolist()
+        num_assets = len(symbols)
+        mean_returns, cov_matrix = self._get_returns_stats(prices_df)
+
+        def neg_sharpe_ratio(weights, mean_ret, cov, rf_rate):
+            p_ret, p_std = self.portfolio_performance(weights, mean_ret, cov)
+            return -(p_ret - rf_rate) / p_std
+
+        args = (mean_returns, cov_matrix, self.risk_free_rate)
+        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        bounds = tuple((0.0, 1.0) for asset in range(num_assets))
+        initial_guess = num_assets * [1. / num_assets,]
+
+        result = minimize(neg_sharpe_ratio, initial_guess, args=args,
+                          method='SLSQP', bounds=bounds, constraints=constraints)
+
+        return {sym: round(weight, 4) for sym, weight in zip(symbols, result.x)}
+
+    def risk_parity(self, prices_df: pd.DataFrame) -> Dict[str, float]:
+        """Inverse volatility weighting (naive risk parity)"""
+        returns = prices_df.pct_change().dropna()
+        volatilities = returns.std() * np.sqrt(252)
+        inv_vol = 1.0 / volatilities
+        weights = inv_vol / inv_vol.sum()
+
+        return {sym: round(weights[sym], 4) for sym in prices_df.columns}
+
+    def combine_agent_signals(self, optimal_weights: Dict[str, float], agent_confidences: Dict[str, float]) -> Dict[str, float]:
+        """
+        Adjust optimal weights based on Agent confidence.
+        For example, if max_sharpe gives AAPL 0.6, but Agent confidence is 0.5,
+        we scale it down and keep remaining in cash.
+        """
+        final_weights = {}
+        for sym, w in optimal_weights.items():
+            conf = agent_confidences.get(sym, 1.0)
+            final_weights[sym] = round(w * conf, 4)
+
+        cash_weight = round(1.0 - sum(final_weights.values()), 4)
+        final_weights['CASH'] = max(0.0, cash_weight)
+
+        return final_weights

aria_code/packages/quant_engine/sports/__init__.py

@@ -0,0 +1,76 @@
+"""
+packages/quant_engine/sports — 足球量化分析模块
+================================================
+v2.0.0 — 2026-06
+
+模块组成:
+  elo          — World Football Elo 动态评分系统（二次曲线攻防，GD K 因子）
+  dixon_coles  — Dixon-Coles 比分预测（NB 分布，大比分悬殊自动启用）
+  form         — 近期状态分析（指数衰减权重）
+  h2h          — 历史交锋分析与调整
+  predictor    — 统一预测引擎 v2（动态权重、赛事情境、ρ 校准）
+  tracker      — 预测追踪、Brier Score、自动 Elo 同步、动态场均进球
+
+快速使用:
+    from packages.quant_engine.sports import quick_predict, get_elo
+
+    # 预测（含 NB 分布 + 动态权重）
+    result = quick_predict("germany", "curacao", league="wc")
+    print(f"德国赢率: {result['home_win']*100:.1f}%")   # ~85%
+
+    # Elo 评分
+    elo = get_elo()
+    print(elo.get_rating("germany"))    # ~1912（赛后更新）
+
+    # 自动同步已结束 WC 比赛 Elo
+    from packages.quant_engine.sports import sync_elo_from_wc
+    sync_elo_from_wc(api_get_fn)
+"""
+
+from .elo          import EloRatingSystem, get_elo, ranking_to_elo
+from .dixon_coles  import (
+    compute_match_probabilities,
+    predict_scoreline_matrix,
+    tau_correction,
+    estimate_rho_from_results,
+    format_dc_result,
+)
+from .form         import analyze_form, parse_api_results, form_bar, momentum_label
+from .h2h          import analyze_h2h
+from .predictor    import FootballPredictor, get_predictor, quick_predict
+from .tracker      import (
+    record_prediction,
+    record_result,
+    get_accuracy_stats,
+    sync_elo_from_wc,
+    fetch_wc_league_avg,
+    fetch_wc_rho,
+    auto_calibrate,
+    backfill_score_metrics,
+)
+from .calibrator   import (
+    get_calibrated_params,
+    get_team_goal_bias,
+    get_all_team_biases,
+    calibration_summary,
+    save_calibration,
+)
+
+__all__ = [
+    "EloRatingSystem", "get_elo", "ranking_to_elo",
+    "compute_match_probabilities", "predict_scoreline_matrix",
+    "tau_correction", "estimate_rho_from_results", "format_dc_result",
+    "analyze_form", "parse_api_results", "form_bar", "momentum_label",
+    "analyze_h2h",
+    "FootballPredictor", "get_predictor", "quick_predict",
+    "record_prediction", "record_result", "get_accuracy_stats",
+    "sync_elo_from_wc", "fetch_wc_league_avg", "fetch_wc_rho", "auto_calibrate",
+    "get_calibrated_params", "get_team_goal_bias", "get_all_team_biases",
+    "calibration_summary", "save_calibration",
+]
+
+__version__ = "2.0.0"
+
+# Optional explicit backend modules never override this distribution.
+from .._namespace import extend as _extend_namespace
+_extend_namespace(__path__, "sports")