hkjc 0.2.0__tar.gz → 0.3.0__tar.gz

{hkjc-0.2.0 → hkjc-0.3.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: hkjc
-Version: 0.2.0
+Version: 0.3.0
 Summary: Library for scrapping HKJC data and perform basic analysis
 Requires-Python: >=3.11
 Requires-Dist: cachetools>=6.2.0
 Requires-Dist: fastexcel>=0.16.0
+Requires-Dist: numba>=0.62.1
 Requires-Dist: numpy>=2.3.3
 Requires-Dist: polars>=1.33.1
 Requires-Dist: pyarrow>=21.0.0

{hkjc-0.2.0 → hkjc-0.3.0}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "hkjc"
-version = "0.2.0"
+version = "0.3.0"
 description = "Library for scrapping HKJC data and perform basic analysis"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "cachetools>=6.2.0",
     "fastexcel>=0.16.0",
+    "numba>=0.62.1",
     "numpy>=2.3.3",
     "polars>=1.33.1",
     "pyarrow>=21.0.0",

{hkjc-0.2.0 → hkjc-0.3.0}/src/hkjc/__init__.py

@@ -5,7 +5,8 @@ This module re-exports commonly used symbols from the submodules.
 from importlib.metadata import version as _version
 
 __all__ = ["live_odds", "qpbanker",
-		    "generate_all_qp_trades", "generate_pareto_qp_trades"]
+		    "generate_all_qp_trades", "generate_pareto_qp_trades",
+			"speedpro_df", "speedmap"]
 
 try:
 	__version__ = _version(__name__)
@@ -14,3 +15,4 @@ except Exception:  # pragma: no cover - best-effort version resolution
 
 from .live_odds import live_odds
 from .processing import generate_all_qp_trades, generate_pareto_qp_trades
+from .speedpro import speedmap, speedpro_df

hkjc-0.3.0/src/hkjc/harville_model.py

@@ -0,0 +1,362 @@
+"""
+Harville Race Model Optimizer
+
+Estimates horse racing outcome probabilities using the Harville model via dynamic
+programming. Fits latent strength parameters from observed betting market odds across
+multiple pool types (Win, Qin, Quinella, Banker).
+
+The optimizer uses O(N * 2^N) complexity DP with Numba JIT compilation for speed.
+Suitable for races with up to ~20 horses.
+
+Example:
+    >>> optimizer = HarvilleOptimizer(n_horses=14)
+    >>> results = optimizer.fit(W_obs=win_odds, Qin_obs=qin_odds, 
+    ...                          Q_obs=quinella_odds, b_obs=banker_odds)
+    >>> print(results['theta'])  # Fitted strength parameters
+"""
+
+import numpy as np
+from scipy.optimize import minimize
+from numba import njit
+from typing import Tuple, Optional
+
+
+@njit(cache=True)
+def _popcount(mask: int) -> int:
+    count = 0
+    while mask:
+        count += 1
+        mask &= mask - 1
+    return count
+
+
+@njit(cache=True)
+def _precompute_mask_info(n: int) -> Tuple[np.ndarray, np.ndarray]:
+    max_mask = 1 << n
+    mask_strength_coef = np.zeros((max_mask, n), dtype=np.float64)
+    mask_popcount = np.zeros(max_mask, dtype=np.int32)
+    
+    for mask in range(max_mask):
+        mask_popcount[mask] = _popcount(mask)
+        for i in range(n):
+            if mask & (1 << i):
+                mask_strength_coef[mask, i] = 1.0
+    
+    return mask_strength_coef, mask_popcount
+
+
+@njit(cache=True)
+def _compute_dp_vectorized(theta: np.ndarray, k_max: int) -> np.ndarray:
+    n = len(theta)
+    max_mask = 1 << n
+    
+    mask_strength_coef, mask_popcount = _precompute_mask_info(n)
+    mask_strength = mask_strength_coef @ theta
+    
+    dp = np.zeros((k_max + 1, max_mask))
+    dp[0, 0] = 1.0
+    
+    for k in range(k_max):
+        valid_masks = np.where(mask_popcount == k)[0]
+        
+        for mask in valid_masks:
+            if dp[k, mask] == 0:
+                continue
+            
+            s_mask = mask_strength[mask]
+            remaining = 1.0 - s_mask
+            
+            if remaining < 1e-12:
+                continue
+            
+            prob_current = dp[k, mask]
+            
+            for i in range(n):
+                if not (mask & (1 << i)):
+                    next_mask = mask | (1 << i)
+                    dp[k + 1, next_mask] += prob_current * theta[i] / remaining
+    
+    return dp
+
+
+@njit(cache=True)
+def _extract_pair_in_top_k(dp: np.ndarray, n: int, k: int) -> np.ndarray:
+    M = np.zeros((n, n))
+    max_mask = 1 << n
+    
+    mask_popcount = np.zeros(max_mask, dtype=np.int32)
+    for mask in range(max_mask):
+        mask_popcount[mask] = _popcount(mask)
+    
+    masks_size_k = np.where(mask_popcount == k)[0]
+    
+    for mask in masks_size_k:
+        prob = dp[k, mask]
+        if prob == 0:
+            continue
+        
+        horses = np.empty(k, dtype=np.int32)
+        idx = 0
+        for i in range(n):
+            if mask & (1 << i):
+                horses[idx] = i
+                idx += 1
+        
+        for i in range(k):
+            for j in range(k):
+                M[horses[i], horses[j]] += prob
+    
+    return M
+
+
+@njit(cache=True)
+def _extract_top_k_probs(dp: np.ndarray, n: int, k_max: int) -> np.ndarray:
+    T = np.zeros((n, k_max + 1))
+    max_mask = 1 << n
+    
+    mask_popcount = np.zeros(max_mask, dtype=np.int32)
+    for mask in range(max_mask):
+        mask_popcount[mask] = _popcount(mask)
+    
+    for k in range(1, k_max + 1):
+        masks_size_k = np.where(mask_popcount == k)[0]
+        
+        for mask in masks_size_k:
+            prob = dp[k, mask]
+            if prob == 0:
+                continue
+            
+            for i in range(n):
+                if mask & (1 << i):
+                    T[i, k] += prob
+    
+    return T
+
+
+@njit(cache=True)
+def _compute_probabilities(theta: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    n = len(theta)
+    
+    dp = _compute_dp_vectorized(theta, n)
+    
+    T = _extract_top_k_probs(dp, n, n)
+    
+    P = np.zeros((n, n))
+    for i in range(n):
+        for j in range(n):
+            P[i, j] = T[i, j + 1] - T[i, j]
+    
+    W = P[:, 0]
+    Qin = _extract_pair_in_top_k(dp, n, 2)
+    Q = _extract_pair_in_top_k(dp, n, 3)
+    b = T[:, 3]
+    
+    return W, Qin, Q, b, P
+
+
+@njit(cache=True)
+def _kl_divergence(p_obs: np.ndarray, p_model: np.ndarray) -> float:
+    eps = 1e-10
+    
+    p_obs_flat = np.maximum(p_obs.ravel(), eps)
+    p_model_flat = np.maximum(p_model.ravel(), eps)
+    
+    sum_obs = p_obs_flat.sum()
+    sum_model = p_model_flat.sum()
+    
+    if sum_obs > eps:
+        p_obs_flat = p_obs_flat / sum_obs
+    if sum_model > eps:
+        p_model_flat = p_model_flat / sum_model
+    
+    return np.sum(p_obs_flat * np.log(p_obs_flat / p_model_flat))
+
+
+class HarvilleOptimizer:
+    """
+    Fits Harville race model to betting market odds using dynamic programming.
+    
+    The Harville model assigns each horse a latent strength parameter theta_i, where
+    the probability of finishing next among remaining horses is proportional to 
+    relative strength. This optimizer estimates theta from observed betting odds
+    across multiple pool types.
+    
+    Default lambda weights (1.0, 2.0, 1.5, 0.7) reflect that early Win odds are
+    biased by informed traders waiting until closing, while exotic pools provide
+    more stable signals for ensemble estimation.
+    
+    Attributes:
+        n (int): Number of horses
+        lambda_win (float): Weight for Win pool loss
+        lambda_qin (float): Weight for Qin pool loss
+        lambda_quinella (float): Weight for Quinella pool loss
+        lambda_banker (float): Weight for Banker pool loss
+    """
+    
+    def __init__(self, n_horses: int, lambda_win: float = 1.0, lambda_qin: float = 2.0, 
+                 lambda_quinella: float = 1.5, lambda_banker: float = 0.7):
+        """
+        Initialize optimizer.
+        
+        Args:
+            n_horses: Number of horses in race (recommend <= 20 for speed)
+            lambda_win: Weight for Win odds (prob horse finishes 1st)
+            lambda_qin: Weight for Qin odds (prob pair finishes 1st-2nd)
+            lambda_quinella: Weight for Quinella odds (prob pair in top 3)
+            lambda_banker: Weight for Banker odds (prob horse in top 3)
+            
+        Raises:
+            ValueError: If n_horses > 20 (exponential complexity warning)
+        """
+        if n_horses > 20:
+            raise ValueError("N > 20 may be too slow (2^N complexity)")
+        
+        self.n = n_horses
+        self.lambda_win = lambda_win
+        self.lambda_qin = lambda_qin
+        self.lambda_quinella = lambda_quinella
+        self.lambda_banker = lambda_banker
+        self._eval_count = 0
+    
+    def loss(self, theta: np.ndarray, W_obs: Optional[np.ndarray], 
+             Qin_obs: Optional[np.ndarray], Q_obs: Optional[np.ndarray], 
+             b_obs: Optional[np.ndarray]) -> float:
+        """
+        Compute weighted KL divergence loss between observed and model odds.
+        
+        Args:
+            theta: Strength parameters (will be normalized to simplex)
+            W_obs: Observed Win probabilities (n,) or None
+            Qin_obs: Observed Qin probabilities (n, n) or None
+            Q_obs: Observed Quinella probabilities (n, n) or None
+            b_obs: Observed Banker probabilities (n,) or None
+            
+        Returns:
+            Scalar loss value (sum of weighted KL divergences)
+        """
+        self._eval_count += 1
+        
+        theta = np.abs(theta) + 1e-10
+        theta = theta / theta.sum()
+        
+        W_model, Qin_model, Q_model, b_model, P_model = _compute_probabilities(theta)
+        
+        loss = 0.0
+        
+        if W_obs is not None:
+            loss += self.lambda_win * _kl_divergence(W_obs, W_model)
+        
+        if Qin_obs is not None:
+            loss += self.lambda_qin * _kl_divergence(Qin_obs, Qin_model)
+        
+        if Q_obs is not None:
+            loss += self.lambda_quinella * _kl_divergence(Q_obs, Q_model)
+        
+        if b_obs is not None:
+            loss += self.lambda_banker * _kl_divergence(b_obs, b_model)
+        
+        return loss
+    
+    def fit(self, W_obs: Optional[np.ndarray] = None, 
+            Qin_obs: Optional[np.ndarray] = None,
+            Q_obs: Optional[np.ndarray] = None, 
+            b_obs: Optional[np.ndarray] = None,
+            theta_init: Optional[np.ndarray] = None, 
+            method: str = 'L-BFGS-B') -> dict:
+        """
+        Fit Harville model to observed betting odds.
+        
+        At least one odds type must be provided. All odds should be probabilities
+        (not decimal/fractional odds). Matrices should be symmetric where applicable.
+        
+        Args:
+            W_obs: Win probabilities, shape (n,). W_obs[i] = prob horse i wins
+            Qin_obs: Qin probabilities, shape (n, n). Qin_obs[i,j] = prob horses
+                     i,j finish 1st-2nd in any order
+            Q_obs: Quinella probabilities, shape (n, n). Q_obs[i,j] = prob horses
+                   i,j both finish in top 3
+            b_obs: Banker probabilities, shape (n,). b_obs[i] = prob horse i 
+                   finishes in top 3
+            theta_init: Initial strength guess (default: W_obs if available, else uniform)
+            method: Scipy optimizer ('L-BFGS-B' or 'SLSQP')
+            
+        Returns:
+            Dictionary containing:
+                - theta: Fitted strength parameters (n,)
+                - W_fitted: Fitted Win probabilities (n,)
+                - Qin_fitted: Fitted Qin probabilities (n, n)
+                - Q_fitted: Fitted Quinella probabilities (n, n)
+                - b_fitted: Fitted Banker probabilities (n,)
+                - P_fitted: Full place probability matrix (n, n), P[i,j] = 
+                            prob horse i finishes in position j
+                - loss: Final loss value
+                - success: Whether optimization converged
+                - message: Optimizer status message
+                - n_eval: Number of loss function evaluations
+                
+        Raises:
+            ValueError: If no odds provided or shapes don't match n_horses
+            
+        Example:
+            >>> opt = HarvilleOptimizer(n_horses=10)
+            >>> results = opt.fit(W_obs=win_probs, Q_obs=quinella_probs)
+            >>> print(f"Fitted strengths: {results['theta']}")
+            >>> print(f"Converged: {results['success']}")
+        """
+        if W_obs is None and Qin_obs is None and Q_obs is None and b_obs is None:
+            raise ValueError("At least one type of odds must be provided")
+        
+        if W_obs is not None and W_obs.shape != (self.n,):
+            raise ValueError(f"W_obs must be ({self.n},)")
+        if Qin_obs is not None and Qin_obs.shape != (self.n, self.n):
+            raise ValueError(f"Qin_obs must be ({self.n}, {self.n})")
+        if Q_obs is not None and Q_obs.shape != (self.n, self.n):
+            raise ValueError(f"Q_obs must be ({self.n}, {self.n})")
+        if b_obs is not None and b_obs.shape != (self.n,):
+            raise ValueError(f"b_obs must be ({self.n},)")
+        
+        if theta_init is None:
+            if W_obs is not None:
+                theta_init = W_obs / W_obs.sum()
+            else:
+                theta_init = np.ones(self.n) / self.n
+        else:
+            theta_init = theta_init / theta_init.sum()
+        
+        self._eval_count = 0
+        
+        if method == 'L-BFGS-B':
+            result = minimize(
+                fun=lambda x: self.loss(x, W_obs, Qin_obs, Q_obs, b_obs),
+                x0=theta_init,
+                method='L-BFGS-B',
+                bounds=[(1e-6, 1.0) for _ in range(self.n)],
+                options={'maxiter': 500, 'ftol': 1e-9, 'maxls': 50}
+            )
+        else:
+            result = minimize(
+                fun=lambda x: self.loss(x, W_obs, Qin_obs, Q_obs, b_obs),
+                x0=theta_init,
+                method='SLSQP',
+                bounds=[(1e-6, 1.0) for _ in range(self.n)],
+                constraints={'type': 'eq', 'fun': lambda x: x.sum() - 1},
+                options={'maxiter': 500, 'ftol': 1e-9}
+            )
+        
+        theta_opt = np.abs(result.x) + 1e-10
+        theta_opt = theta_opt / theta_opt.sum()
+        
+        W_fitted, Qin_fitted, Q_fitted, b_fitted, P_fitted = _compute_probabilities(theta_opt)
+        
+        return {
+            'theta': theta_opt,
+            'W_fitted': W_fitted,
+            'Qin_fitted': Qin_fitted,
+            'Q_fitted': Q_fitted,
+            'b_fitted': b_fitted,
+            'P_fitted': P_fitted,
+            'loss': result.fun,
+            'success': result.success,
+            'message': result.message,
+            'n_eval': self._eval_count
+        }

{hkjc-0.2.0 → hkjc-0.3.0}/src/hkjc/processing.py

@@ -6,6 +6,7 @@ from typing import Tuple, List
 from .live_odds import live_odds
 from .qpbanker import win_probability, expected_value, average_odds
 from .optimization import _pareto_filter
+from .harville_model import HarvilleOptimizer
 
 import polars as pl
 import numpy as np
@@ -26,7 +27,7 @@ def _process_single_qp_trade(banker: int, covered: List[int], odds_pla: List[flo
     return (banker, covered, win_prob, exp_value, ave_odds)
 
 
-def generate_all_qp_trades(date: str, venue_code: str, race_number: int, rebate: float = 0.12) -> pl.DataFrame:
+def generate_all_qp_trades(date: str, venue_code: str, race_number: int, rebate: float = 0.12, harville_fit=True) -> pl.DataFrame:
     """Generate all possible qp tickets for the specified race.
 
     Args:
@@ -34,14 +35,25 @@ def generate_all_qp_trades(date: str, venue_code: str, race_number: int, rebate:
         venue_code (str): Venue code, e.g., 'ST' for Shatin, 'HV' for Happy Valley.
         race_number (int): Race number.
         rebate (float, optional): The rebate percentage. Defaults to 0.12.
+        harville_fit (bool, optional): Whether to fit the odds using Harville model. Defaults to True.
 
     Returns:
         pl.DataFrame: DataFrame with all possible trades and their metrics.
     """
-    odds = live_odds(date, venue_code, race_number, odds_type=['PLA', 'QPL'])
+
+    odds = live_odds(date, venue_code, race_number,
+                     odds_type=['PLA', 'QPL', 'WIN', 'QIN'])
     N = len(odds['PLA'])
     candidates = np.arange(1, N+1)
 
+    if harville_fit:
+        ho = HarvilleOptimizer(N)
+        fit_res = ho.fit(1/odds['WIN'], 1/odds['QIN'],
+                         1/odds['QPL'], 1/odds['PLA'])
+        if fit_res['success']:
+            odds['PLA'] = 1/fit_res['b_fitted']
+            odds['QPL'] = 1/fit_res['Q_fitted']
+
     results = [_process_single_qp_trade(banker, covered, odds['PLA'], odds['QPL'], rebate)
                for banker in tqdm(candidates, desc="Processing bankers")
                for covered in _all_subsets(candidates[candidates != banker])]

{hkjc-0.2.0 → hkjc-0.3.0}/uv.lock

@@ -97,11 +97,12 @@ wheels = [
 
 [[package]]
 name = "hkjc"
-version = "0.2.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "cachetools" },
     { name = "fastexcel" },
+    { name = "numba" },
     { name = "numpy" },
     { name = "polars" },
     { name = "pyarrow" },
@@ -114,6 +115,7 @@ dependencies = [
 requires-dist = [
     { name = "cachetools", specifier = ">=6.2.0" },
     { name = "fastexcel", specifier = ">=0.16.0" },
+    { name = "numba", specifier = ">=0.62.1" },
     { name = "numpy", specifier = ">=2.3.3" },
     { name = "polars", specifier = ">=1.33.1" },
     { name = "pyarrow", specifier = ">=21.0.0" },
@@ -131,6 +133,56 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
 ]
 
+[[package]]
+name = "llvmlite"
+version = "0.45.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/99/8d/5baf1cef7f9c084fb35a8afbde88074f0d6a727bc63ef764fe0e7543ba40/llvmlite-0.45.1.tar.gz", hash = "sha256:09430bb9d0bb58fc45a45a57c7eae912850bedc095cd0810a57de109c69e1c32", size = 185600, upload-time = "2025-10-01T17:59:52.046Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/ad/9bdc87b2eb34642c1cfe6bcb4f5db64c21f91f26b010f263e7467e7536a3/llvmlite-0.45.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:60f92868d5d3af30b4239b50e1717cb4e4e54f6ac1c361a27903b318d0f07f42", size = 43043526, upload-time = "2025-10-01T18:03:15.051Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ea/c25c6382f452a943b4082da5e8c1665ce29a62884e2ec80608533e8e82d5/llvmlite-0.45.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:98baab513e19beb210f1ef39066288784839a44cd504e24fff5d17f1b3cf0860", size = 37253118, upload-time = "2025-10-01T18:04:06.783Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/af/85fc237de98b181dbbe8647324331238d6c52a3554327ccdc83ced28efba/llvmlite-0.45.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3adc2355694d6a6fbcc024d59bb756677e7de506037c878022d7b877e7613a36", size = 56288209, upload-time = "2025-10-01T18:01:00.168Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/df/3daf95302ff49beff4230065e3178cd40e71294968e8d55baf4a9e560814/llvmlite-0.45.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f3377a6db40f563058c9515dedcc8a3e562d8693a106a28f2ddccf2c8fcf6ca", size = 55140958, upload-time = "2025-10-01T18:02:11.199Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/56/4c0d503fe03bac820ecdeb14590cf9a248e120f483bcd5c009f2534f23f0/llvmlite-0.45.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9c272682d91e0d57f2a76c6d9ebdfccc603a01828cdbe3d15273bdca0c3363a", size = 38132232, upload-time = "2025-10-01T18:04:52.181Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/7c/82cbd5c656e8991bcc110c69d05913be2229302a92acb96109e166ae31fb/llvmlite-0.45.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:28e763aba92fe9c72296911e040231d486447c01d4f90027c8e893d89d49b20e", size = 43043524, upload-time = "2025-10-01T18:03:30.666Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/bc/5314005bb2c7ee9f33102c6456c18cc81745d7055155d1218f1624463774/llvmlite-0.45.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1a53f4b74ee9fd30cb3d27d904dadece67a7575198bd80e687ee76474620735f", size = 37253123, upload-time = "2025-10-01T18:04:18.177Z" },
+    { url = "https://files.pythonhosted.org/packages/96/76/0f7154952f037cb320b83e1c952ec4a19d5d689cf7d27cb8a26887d7bbc1/llvmlite-0.45.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b3796b1b1e1c14dcae34285d2f4ea488402fbd2c400ccf7137603ca3800864f", size = 56288211, upload-time = "2025-10-01T18:01:24.079Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b1/0b581942be2683ceb6862d558979e87387e14ad65a1e4db0e7dd671fa315/llvmlite-0.45.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:779e2f2ceefef0f4368548685f0b4adde34e5f4b457e90391f570a10b348d433", size = 55140958, upload-time = "2025-10-01T18:02:30.482Z" },
+    { url = "https://files.pythonhosted.org/packages/33/94/9ba4ebcf4d541a325fd8098ddc073b663af75cc8b065b6059848f7d4dce7/llvmlite-0.45.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e6c9949baf25d9aa9cd7cf0f6d011b9ca660dd17f5ba2b23bdbdb77cc86b116", size = 38132231, upload-time = "2025-10-01T18:05:03.664Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/e2/c185bb7e88514d5025f93c6c4092f6120c6cea8fe938974ec9860fb03bbb/llvmlite-0.45.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:d9ea9e6f17569a4253515cc01dade70aba536476e3d750b2e18d81d7e670eb15", size = 43043524, upload-time = "2025-10-01T18:03:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/09/b8/b5437b9ecb2064e89ccf67dccae0d02cd38911705112dd0dcbfa9cd9a9de/llvmlite-0.45.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:c9f3cadee1630ce4ac18ea38adebf2a4f57a89bd2740ce83746876797f6e0bfb", size = 37253121, upload-time = "2025-10-01T18:04:30.557Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/97/ad1a907c0173a90dd4df7228f24a3ec61058bc1a9ff8a0caec20a0cc622e/llvmlite-0.45.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:57c48bf2e1083eedbc9406fb83c4e6483017879714916fe8be8a72a9672c995a", size = 56288210, upload-time = "2025-10-01T18:01:40.26Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d8/c99c8ac7a326e9735401ead3116f7685a7ec652691aeb2615aa732b1fc4a/llvmlite-0.45.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3aa3dfceda4219ae39cf18806c60eeb518c1680ff834b8b311bd784160b9ce40", size = 55140957, upload-time = "2025-10-01T18:02:46.244Z" },
+    { url = "https://files.pythonhosted.org/packages/09/56/ed35668130e32dbfad2eb37356793b0a95f23494ab5be7d9bf5cb75850ee/llvmlite-0.45.1-cp313-cp313-win_amd64.whl", hash = "sha256:080e6f8d0778a8239cd47686d402cb66eb165e421efa9391366a9b7e5810a38b", size = 38132232, upload-time = "2025-10-01T18:05:14.477Z" },
+]
+
+[[package]]
+name = "numba"
+version = "0.62.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "llvmlite" },
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/20/33dbdbfe60e5fd8e3dbfde299d106279a33d9f8308346022316781368591/numba-0.62.1.tar.gz", hash = "sha256:7b774242aa890e34c21200a1fc62e5b5757d5286267e71103257f4e2af0d5161", size = 2749817, upload-time = "2025-09-29T10:46:31.551Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/5f/8b3491dd849474f55e33c16ef55678ace1455c490555337899c35826836c/numba-0.62.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:f43e24b057714e480fe44bc6031de499e7cf8150c63eb461192caa6cc8530bc8", size = 2684279, upload-time = "2025-09-29T10:43:37.213Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/18/71969149bfeb65a629e652b752b80167fe8a6a6f6e084f1f2060801f7f31/numba-0.62.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:57cbddc53b9ee02830b828a8428757f5c218831ccc96490a314ef569d8342b7b", size = 2687330, upload-time = "2025-09-29T10:43:59.601Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/7d/403be3fecae33088027bc8a95dc80a2fda1e3beff3e0e5fc4374ada3afbe/numba-0.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:604059730c637c7885386521bb1b0ddcbc91fd56131a6dcc54163d6f1804c872", size = 3739727, upload-time = "2025-09-29T10:42:45.922Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/c3/3d910d08b659a6d4c62ab3cd8cd93c4d8b7709f55afa0d79a87413027ff6/numba-0.62.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6c540880170bee817011757dc9049dba5a29db0c09b4d2349295991fe3ee55f", size = 3445490, upload-time = "2025-09-29T10:43:12.692Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/82/9d425c2f20d9f0a37f7cb955945a553a00fa06a2b025856c3550227c5543/numba-0.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:03de6d691d6b6e2b76660ba0f38f37b81ece8b2cc524a62f2a0cfae2bfb6f9da", size = 2745550, upload-time = "2025-09-29T10:44:20.571Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/fa/30fa6873e9f821c0ae755915a3ca444e6ff8d6a7b6860b669a3d33377ac7/numba-0.62.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:1b743b32f8fa5fff22e19c2e906db2f0a340782caf024477b97801b918cf0494", size = 2685346, upload-time = "2025-09-29T10:43:43.677Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/d5/504ce8dc46e0dba2790c77e6b878ee65b60fe3e7d6d0006483ef6fde5a97/numba-0.62.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90fa21b0142bcf08ad8e32a97d25d0b84b1e921bc9423f8dda07d3652860eef6", size = 2688139, upload-time = "2025-09-29T10:44:04.894Z" },
+    { url = "https://files.pythonhosted.org/packages/50/5f/6a802741176c93f2ebe97ad90751894c7b0c922b52ba99a4395e79492205/numba-0.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6ef84d0ac19f1bf80431347b6f4ce3c39b7ec13f48f233a48c01e2ec06ecbc59", size = 3796453, upload-time = "2025-09-29T10:42:52.771Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/df/efd21527d25150c4544eccc9d0b7260a5dec4b7e98b5a581990e05a133c0/numba-0.62.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9315cc5e441300e0ca07c828a627d92a6802bcbf27c5487f31ae73783c58da53", size = 3496451, upload-time = "2025-09-29T10:43:19.279Z" },
+    { url = "https://files.pythonhosted.org/packages/80/44/79bfdab12a02796bf4f1841630355c82b5a69933b1d50eb15c7fa37dabe8/numba-0.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:44e3aa6228039992f058f5ebfcfd372c83798e9464297bdad8cc79febcf7891e", size = 2745552, upload-time = "2025-09-29T10:44:26.399Z" },
+    { url = "https://files.pythonhosted.org/packages/22/76/501ea2c07c089ef1386868f33dff2978f43f51b854e34397b20fc55e0a58/numba-0.62.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:b72489ba8411cc9fdcaa2458d8f7677751e94f0109eeb53e5becfdc818c64afb", size = 2685766, upload-time = "2025-09-29T10:43:49.161Z" },
+    { url = "https://files.pythonhosted.org/packages/80/68/444986ed95350c0611d5c7b46828411c222ce41a0c76707c36425d27ce29/numba-0.62.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:44a1412095534a26fb5da2717bc755b57da5f3053965128fe3dc286652cc6a92", size = 2688741, upload-time = "2025-09-29T10:44:10.07Z" },
+    { url = "https://files.pythonhosted.org/packages/78/7e/bf2e3634993d57f95305c7cee4c9c6cb3c9c78404ee7b49569a0dfecfe33/numba-0.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8c9460b9e936c5bd2f0570e20a0a5909ee6e8b694fd958b210e3bde3a6dba2d7", size = 3804576, upload-time = "2025-09-29T10:42:59.53Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/b6/8a1723fff71f63bbb1354bdc60a1513a068acc0f5322f58da6f022d20247/numba-0.62.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:728f91a874192df22d74e3fd42c12900b7ce7190b1aad3574c6c61b08313e4c5", size = 3503367, upload-time = "2025-09-29T10:43:26.326Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ec/9d414e7a80d6d1dc4af0e07c6bfe293ce0b04ea4d0ed6c45dad9bd6e72eb/numba-0.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:bbf3f88b461514287df66bc8d0307e949b09f2b6f67da92265094e8fa1282dd8", size = 2745529, upload-time = "2025-09-29T10:44:31.738Z" },
+]
+
 [[package]]
 name = "numpy"
 version = "2.3.3"

hkjc-0.2.0/.pypirc

@@ -1,3 +0,0 @@
-[pypi]
-  username = __token__
-  password = pypi-AgEIcHlwaS5vcmcCJGE5YmQ1Yzk5LTc1ZWItNGY3ZC05NTI4LTVhYmI3NTM4ODJiMAACKlszLCIzYTBjMDk5Mi0wOWMwLTQyM2MtYmJlNy1iNzQ0Nzg0OTI0NDAiXQAABiAEoMJ9FkQWPptAjnP6UqkrcCuHfhKamypJ6H3jMiv5Eg

hkjc-0.2.0/src/hkjc/odds_fitting.py

@@ -1 +0,0 @@
-## TODO: implement odds filtering