hkjc 0.3.21__tar.gz → 0.3.22__tar.gz

{hkjc-0.3.21 → hkjc-0.3.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hkjc
-Version: 0.3.21
+Version: 0.3.22
 Summary: Library for scrapping HKJC data and perform basic analysis
 Requires-Python: >=3.11
 Requires-Dist: beautifulsoup4>=4.14.2

{hkjc-0.3.21 → hkjc-0.3.22}/dashboard/app.py

@@ -32,21 +32,24 @@ app = Flask(__name__)
 def disp_race_info():
     race_info = _fetch_live_races('', '')
 
-    df_speedpro = speedpro_energy(race_info['Date'])
-    for race_num, race in race_info['Races'].items():
-        for i, runner in enumerate(race['Runners']):
-            df = (df_speedpro
-                  .filter(pl.col('RaceNo') == race_num)
-                  .filter(pl.col('RunnerNumber') == int(runner['No']))
-                  )
-            race_info['Races'][race_num]['Runners'][i]['SPEnergy'] = df['SpeedPRO_Energy_Difference'].item(
-                0)
-            race_info['Races'][race_num]['Runners'][i]['Fitness'] = df['FitnessRatings'].item(
-                0)
-
-# TODO: add horse running style favorite from horse info
-# get_horse_data
-# pack favorite running style
+    try:
+        df_speedpro = speedpro_energy(race_info['Date'])
+        for race_num, race in race_info['Races'].items():
+            for i, runner in enumerate(race['Runners']):
+                df = (df_speedpro
+                      .filter(pl.col('RaceNo') == race_num)
+                      .filter(pl.col('RunnerNumber') == int(runner['No']))
+                      )
+                race_info['Races'][race_num]['Runners'][i]['SPEnergy'] = df['SpeedPRO_Energy_Difference'].item(
+                    0)
+                race_info['Races'][race_num]['Runners'][i]['Fitness'] = df['FitnessRatings'].item(
+                    0)
+    except:  # fill with dummy value if SpeedPro not available
+        for race_num, race in race_info['Races'].items():
+            for i, runner in enumerate(race['Runners']):
+                race_info['Races'][race_num]['Runners'][i]['SPEnergy'] = 0
+                race_info['Races'][race_num]['Runners'][i]['Fitness'] = 0
+
     return render_template('index.html',
                            race_info=race_info)
 

{hkjc-0.3.21 → hkjc-0.3.22}/dashboard/static/script.js

@@ -6,10 +6,41 @@
 // CONFIGURATION
 // ============================================================================
 const CONFIG = {
-    ODDS_POLL_INTERVAL: 90000,        // 90 seconds
-    REQUEST_DELAY: 100,                // Delay between sequential requests (ms)
+    ODDS_POLL_INTERVAL: 90000,        // 90 seconds (base)
+    POLL_JITTER: 10000,                // ±5 seconds jitter for polling
+    MIN_REQUEST_DELAY: 80,             // Min delay between requests (ms)
+    MAX_REQUEST_DELAY: 250,            // Max delay between requests (ms)
     MAX_CONCURRENT_REQUESTS: 3,        // Max simultaneous requests
-    REQUEST_TIMEOUT: 10000             // 10 second timeout
+    REQUEST_TIMEOUT: 10000,            // 10 second timeout
+    DEBUG: false                       // Enable debug logging
+};
+
+// ============================================================================
+// UTILITIES
+// ============================================================================
+const Utils = {
+    /**
+     * Get runner row data from HTML element
+     */
+    getRunnerData(row) {
+        return {
+            raceNum: row.dataset.race,
+            horseNo: row.dataset.horse,
+            going: row.dataset.going || '',
+            track: row.dataset.track || '',
+            distance: row.dataset.dist || '',
+            runnerNo: row.querySelector('.odds-win')?.dataset.horse || row.dataset.horse
+        };
+    },
+
+    /**
+     * Conditional debug logging
+     */
+    log(...args) {
+        if (CONFIG.DEBUG) {
+            console.log(...args);
+        }
+    }
 };
 
 // ============================================================================
@@ -24,7 +55,7 @@ const State = {
     polling: {
         oddsIntervalId: null
     },
-    activeRequests: new Set()
+    raceReadiness: new Map()
 };
 
 // ============================================================================
@@ -34,9 +65,6 @@ const RequestQueue = {
     queue: [],
     activeCount: 0,
     
-    /**
-     * Add request to queue with priority support
-     */
     async enqueue(requestFn, priority = 0) {
         return new Promise((resolve, reject) => {
             this.queue.push({ requestFn, resolve, reject, priority });
@@ -45,9 +73,6 @@ const RequestQueue = {
         });
     },
     
-    /**
-     * Process queued requests with concurrency limit
-     */
     async process() {
         if (this.activeCount >= CONFIG.MAX_CONCURRENT_REQUESTS || this.queue.length === 0) {
             return;
@@ -63,22 +88,19 @@ const RequestQueue = {
             reject(error);
         } finally {
             this.activeCount--;
-            // Small delay between requests
-            await this.delay(CONFIG.REQUEST_DELAY);
+            await this.delay(this.getRandomDelay());
             this.process();
         }
     },
     
-    /**
-     * Clear all pending requests
-     */
+    getRandomDelay() {
+        return Math.random() * (CONFIG.MAX_REQUEST_DELAY - CONFIG.MIN_REQUEST_DELAY) + CONFIG.MIN_REQUEST_DELAY;
+    },
+    
     clear() {
         this.queue = [];
     },
     
-    /**
-     * Helper delay function
-     */
     delay(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
@@ -88,9 +110,6 @@ const RequestQueue = {
 // API MODULE - All server communication
 // ============================================================================
 const API = {
-    /**
-     * Generic fetch wrapper with timeout and error handling
-     */
     async fetch(url, options = {}) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), CONFIG.REQUEST_TIMEOUT);
@@ -117,19 +136,13 @@ const API = {
         }
     },
     
-    /**
-     * Fetch live odds for a race
-     */
     async fetchOdds(raceNum) {
         return RequestQueue.enqueue(async () => {
             const response = await this.fetch(`/live_odds/${raceNum}`);
             return await response.json();
-        }, 1); // Priority 1 for odds
+        }, 1);
     },
     
-    /**
-     * Fetch horse history
-     */
     async fetchHorseHistory(horseNo, going, track, distance) {
         return RequestQueue.enqueue(async () => {
             const params = new URLSearchParams({
@@ -139,17 +152,14 @@ const API = {
             });
             const response = await this.fetch(`/horse_info/${horseNo}?${params}`);
             return await response.text();
-        }, 0); // Priority 0 for history
+        }, 0);
     },
     
-    /**
-     * Fetch speedmap
-     */
     async fetchSpeedmap(raceNum) {
         return RequestQueue.enqueue(async () => {
             const response = await this.fetch(`/speedmap/${raceNum}`);
             return await response.text();
-        }, 0); // Priority 0 for speedmaps
+        }, 0);
     }
 };
 
@@ -181,14 +191,51 @@ const Cache = {
     }
 };
 
+// ============================================================================
+// RACE READINESS MODULE - Check if speed pro data is available
+// ============================================================================
+const RaceReadiness = {
+    isReady(raceNum) {
+        if (State.raceReadiness.has(raceNum)) {
+            return State.raceReadiness.get(raceNum);
+        }
+        
+        const ready = this.checkRaceData(raceNum);
+        State.raceReadiness.set(raceNum, ready);
+        return ready;
+    },
+    
+    checkRaceData(raceNum) {
+        const raceContent = document.getElementById(`race-${raceNum}`);
+        if (!raceContent) return false;
+        
+        const runnerRows = raceContent.querySelectorAll('.runner-row');
+        if (runnerRows.length === 0) return false;
+        
+        // Check if any runner has non-zero fitness or energy
+        return Array.from(runnerRows).some(row => {
+            const fitness = parseFloat(row.cells[8]?.textContent.trim()) || 0;
+            const energy = parseFloat(row.cells[9]?.textContent.trim()) || 0;
+            return fitness !== 0 || energy !== 0;
+        });
+    },
+    
+    recheck(raceNum) {
+        State.raceReadiness.delete(raceNum);
+        return this.isReady(raceNum);
+    }
+};
+
 // ============================================================================
 // ODDS MODULE - Live odds management
 // ============================================================================
 const Odds = {
-    /**
-     * Fetch and cache odds for a race
-     */
     async load(raceNum) {
+        if (!RaceReadiness.isReady(raceNum)) {
+            Utils.log(`Skipping odds for race ${raceNum} - race not ready`);
+            return null;
+        }
+        
         try {
             const data = await API.fetchOdds(raceNum);
             Cache.set('odds', raceNum, data);
@@ -200,33 +247,23 @@ const Odds = {
         }
     },
     
-    /**
-     * Update odds display in UI
-     */
     updateDisplay(raceNum, oddsData) {
         if (!oddsData?.Raw || !oddsData?.Fit) return;
         
-        // Update WIN columns
         this.updateCells(`.odds-win[data-race="${raceNum}"]`, oddsData.Raw.WIN);
         this.updateCells(`.odds-win-fit[data-race="${raceNum}"]`, oddsData.Fit.WIN);
-        
-        // Update PLA columns
         this.updateCells(`.odds-pla[data-race="${raceNum}"]`, oddsData.Raw.PLA);
         this.updateCells(`.odds-pla-fit[data-race="${raceNum}"]`, oddsData.Fit.PLA);
         
-        // Update odds tables in expanded sections
         document.querySelectorAll(`.odds-table[data-race="${raceNum}"]`).forEach(table => {
-            const horseNo = table.getAttribute('data-horse');
+            const horseNo = table.dataset.horse;
             this.updateOddsTable(table, horseNo, oddsData);
         });
     },
     
-    /**
-     * Helper to update cells with odds data
-     */
     updateCells(selector, oddsData) {
         document.querySelectorAll(selector).forEach(cell => {
-            const horseNo = cell.getAttribute('data-horse');
+            const horseNo = cell.dataset.horse;
             const odds = oddsData?.[horseNo];
             if (odds !== undefined) {
                 cell.textContent = odds;
@@ -234,9 +271,6 @@ const Odds = {
         });
     },
     
-    /**
-     * Update combination odds table
-     */
     updateOddsTable(table, horseNo, oddsData) {
         const allHorses = Object.keys(oddsData.Raw.WIN || {}).sort((a, b) => parseInt(a) - parseInt(b));
         const otherHorses = allHorses.filter(h => h !== horseNo);
@@ -254,15 +288,12 @@ const Odds = {
             });
         };
         
-        updateRow(0, oddsData.Raw.QIN);     // QIN
-        updateRow(1, oddsData.Fit.QIN);     // QIN (fit)
-        updateRow(2, oddsData.Raw.QPL);     // QPL
-        updateRow(3, oddsData.Fit.QPL);     // QPL (fit)
+        updateRow(0, oddsData.Raw.QIN);
+        updateRow(1, oddsData.Fit.QIN);
+        updateRow(2, oddsData.Raw.QPL);
+        updateRow(3, oddsData.Fit.QPL);
     },
     
-    /**
-     * Create HTML for odds section
-     */
     createSection(raceNum, horseNo, oddsData) {
         if (!oddsData?.Raw || !oddsData?.Fit) return '';
         
@@ -271,15 +302,6 @@ const Odds = {
         
         if (otherHorses.length === 0) return '';
         
-        let html = '<div class="odds-table-container">';
-        html += `<table class="odds-table" data-race="${raceNum}" data-horse="${horseNo}">`;
-        html += '<thead><tr><th>Type</th>';
-        
-        // Header row
-        otherHorses.forEach(h => html += `<th>vs ${h}</th>`);
-        html += '</tr></thead><tbody>';
-        
-        // Data rows
         const createRow = (label, data) => {
             let row = `<tr><td class="odds-type-label">${label}</td>`;
             otherHorses.forEach(h => {
@@ -289,18 +311,26 @@ const Odds = {
             return row + '</tr>';
         };
         
-        html += createRow('QIN', oddsData.Raw.QIN);
-        html += createRow('QIN (fit)', oddsData.Fit.QIN);
-        html += createRow('QPL', oddsData.Raw.QPL);
-        html += createRow('QPL (fit)', oddsData.Fit.QPL);
-        
-        html += '</tbody></table></div>';
-        return html;
+        return `
+            <div class="odds-table-container">
+                <table class="odds-table" data-race="${raceNum}" data-horse="${horseNo}">
+                    <thead>
+                        <tr>
+                            <th>Type</th>
+                            ${otherHorses.map(h => `<th>vs ${h}</th>`).join('')}
+                        </tr>
+                    </thead>
+                    <tbody>
+                        ${createRow('QIN', oddsData.Raw.QIN)}
+                        ${createRow('QIN (fit)', oddsData.Fit.QIN)}
+                        ${createRow('QPL', oddsData.Raw.QPL)}
+                        ${createRow('QPL (fit)', oddsData.Fit.QPL)}
+                    </tbody>
+                </table>
+            </div>
+        `;
     },
     
-    /**
-     * Start polling for live odds
-     */
     startPolling() {
         const allRaceNums = Array.from(document.querySelectorAll('.race-content'))
             .map(el => el.id.replace('race-', ''));
@@ -310,21 +340,26 @@ const Odds = {
         
         // Clear existing interval
         if (State.polling.oddsIntervalId) {
-            clearInterval(State.polling.oddsIntervalId);
+            clearTimeout(State.polling.oddsIntervalId);
         }
         
-        // Set up polling
-        State.polling.oddsIntervalId = setInterval(() => {
-            allRaceNums.forEach(raceNum => this.load(raceNum));
-        }, CONFIG.ODDS_POLL_INTERVAL);
+        // Set up polling with jitter
+        const scheduleNextPoll = () => {
+            const jitter = Math.random() * CONFIG.POLL_JITTER - (CONFIG.POLL_JITTER / 2);
+            const nextInterval = CONFIG.ODDS_POLL_INTERVAL + jitter;
+            
+            State.polling.oddsIntervalId = setTimeout(() => {
+                allRaceNums.forEach(raceNum => this.load(raceNum));
+                scheduleNextPoll();
+            }, nextInterval);
+        };
+        
+        scheduleNextPoll();
     },
     
-    /**
-     * Stop polling
-     */
     stopPolling() {
         if (State.polling.oddsIntervalId) {
-            clearInterval(State.polling.oddsIntervalId);
+            clearTimeout(State.polling.oddsIntervalId);
             State.polling.oddsIntervalId = null;
         }
     }
@@ -334,19 +369,86 @@ const Odds = {
 // RUNNER DETAILS MODULE - Horse history and details
 // ============================================================================
 const RunnerDetails = {
-    /**
-     * Load runner details (history)
-     */
+    extractRunningStyles(historyHtml) {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(historyHtml, 'text/html');
+        const table = doc.querySelector('table');
+        
+        if (!table) return [];
+        
+        // Find Style column
+        const headerRow = table.querySelector('thead tr');
+        if (!headerRow) return [];
+        
+        const headers = Array.from(headerRow.querySelectorAll('th'));
+        const styleColumnIndex = headers.findIndex(th => 
+            th.textContent.trim().toLowerCase() === 'style'
+        );
+        
+        if (styleColumnIndex === -1) return [];
+        
+        // Extract styles from top 5 rows
+        const rows = Array.from(table.querySelectorAll('tbody tr'));
+        const styles = [];
+        
+        for (let i = 0; i < Math.min(5, rows.length); i++) {
+            const cells = rows[i].querySelectorAll('td');
+            if (styleColumnIndex < cells.length) {
+                const styleText = cells[styleColumnIndex].textContent.trim();
+                if (styleText) {
+                    styles.push(styleText);
+                }
+            }
+        }
+        
+        return styles;
+    },
+    
+    calculateMode(arr) {
+        if (!arr || arr.length === 0) return null;
+        
+        const frequency = {};
+        let maxFreq = 0;
+        let mode = null;
+        
+        arr.forEach(value => {
+            frequency[value] = (frequency[value] || 0) + 1;
+            if (frequency[value] > maxFreq) {
+                maxFreq = frequency[value];
+                mode = value;
+            }
+        });
+        
+        return mode;
+    },
+    
+    updateFavStyle(raceNum, horseNo, historyHtml) {
+        const cell = document.querySelector(`.fav-style[data-race="${raceNum}"][data-horse="${horseNo}"]`);
+        if (!cell) return;
+        
+        try {
+            const styles = this.extractRunningStyles(historyHtml);
+            const favStyle = this.calculateMode(styles);
+            cell.textContent = favStyle || '-';
+        } catch (error) {
+            console.error(`Error updating fav style for horse ${horseNo}:`, error);
+            cell.textContent = '-';
+        }
+    },
+    
     async load(raceNum, horseNo, going, track, distance) {
         const cacheKey = `${raceNum}-${horseNo}`;
         
         if (Cache.has('runnerDetails', cacheKey)) {
-            return Cache.get('runnerDetails', cacheKey);
+            const cachedHtml = Cache.get('runnerDetails', cacheKey);
+            this.updateFavStyle(raceNum, horseNo, cachedHtml);
+            return cachedHtml;
         }
         
         try {
             const html = await API.fetchHorseHistory(horseNo, going, track, distance);
             Cache.set('runnerDetails', cacheKey, html);
+            this.updateFavStyle(raceNum, horseNo, html);
             return html;
         } catch (error) {
             console.error(`Error loading history for horse ${horseNo}:`, error);
@@ -354,52 +456,29 @@ const RunnerDetails = {
         }
     },
     
-    /**
-     * Create complete details content (odds + history)
-     */
     createContent(raceNum, runnerNo, horseNo, oddsData, historyHtml) {
-        let content = '<div class="runner-details-wrapper">';
-        
-        // Add odds section if available
-        if (oddsData) {
-            content += '<div class="details-left">';
-            content += Odds.createSection(raceNum, runnerNo, oddsData);
-            content += '</div>';
-        }
-        
-        // Add history section
-        content += '<div class="details-right">';
-        content += historyHtml;
-        content += '</div>';
-        
-        content += '</div>';
-        
-        return content;
+        const oddsSection = oddsData ? `<div class="details-left">${Odds.createSection(raceNum, runnerNo, oddsData)}</div>` : '';
+        const historySection = `<div class="details-right">${historyHtml}</div>`;
+        return `<div class="runner-details-wrapper">${oddsSection}${historySection}</div>`;
     },
     
-    /**
-     * Toggle single runner details
-     */
     async toggle(rowElement, raceNum, horseNo, going, track, distance) {
         const detailsRow = document.getElementById(`runner-details-${raceNum}-${horseNo}`);
         const isExpanded = detailsRow.classList.contains('expanded');
         
         if (isExpanded) {
-            // Collapse
             detailsRow.classList.remove('expanded');
             rowElement.querySelector('.expand-icon').classList.remove('expanded');
         } else {
-            // Expand
             detailsRow.classList.add('expanded');
             rowElement.querySelector('.expand-icon').classList.add('expanded');
             
             const detailsContent = document.getElementById(`runner-details-content-${raceNum}-${horseNo}`);
-            const runnerNo = rowElement.querySelector('.odds-win')?.getAttribute('data-horse') || horseNo;
+            const runnerNo = rowElement.querySelector('.odds-win')?.dataset.horse || horseNo;
             const oddsData = Cache.get('odds', raceNum);
             const cacheKey = `${raceNum}-${horseNo}`;
             
             if (!Cache.has('runnerDetails', cacheKey)) {
-                // Show loading state
                 detailsContent.innerHTML = this.createContent(
                     raceNum, runnerNo, horseNo, oddsData,
                     '<div class="details-loading">Loading race history...</div>'
@@ -411,7 +490,7 @@ const RunnerDetails = {
                 } catch (error) {
                     detailsContent.innerHTML = this.createContent(
                         raceNum, runnerNo, horseNo, oddsData,
-                        `<div class="details-loading error">Error loading race history: ${error.message}</div>`
+                        `<div class="details-loading error">Error: ${error.message}</div>`
                     );
                 }
             } else {
@@ -423,100 +502,111 @@ const RunnerDetails = {
         UI.updateExpandAllButtonState(raceNum);
     },
     
-    /**
-     * Toggle all runners with sequential loading
-     */
+    async loadRunnerData(raceNum, runnerData, oddsData) {
+        const { horseNo, runnerNo, going, track, distance } = runnerData;
+        const cacheKey = `${raceNum}-${horseNo}`;
+        const detailsContent = document.getElementById(`runner-details-content-${raceNum}-${horseNo}`);
+        const detailsRow = document.getElementById(`runner-details-${raceNum}-${horseNo}`);
+        
+        if (!Cache.has('runnerDetails', cacheKey)) {
+            try {
+                const historyHtml = await this.load(raceNum, horseNo, going, track, distance);
+                
+                if (detailsRow.classList.contains('expanded')) {
+                    const currentOddsData = Cache.get('odds', raceNum);
+                    detailsContent.innerHTML = this.createContent(raceNum, runnerNo, horseNo, currentOddsData, historyHtml);
+                }
+            } catch (error) {
+                if (detailsRow.classList.contains('expanded')) {
+                    const currentOddsData = Cache.get('odds', raceNum);
+                    detailsContent.innerHTML = this.createContent(
+                        raceNum, runnerNo, horseNo, currentOddsData,
+                        `<div class="details-loading error">Error: ${error.message}</div>`
+                    );
+                }
+            }
+        }
+    },
+    
     async toggleAll(raceNum, buttonElement) {
         const raceContent = document.getElementById(`race-${raceNum}`);
         const runnerRows = Array.from(raceContent.querySelectorAll('.runner-row'));
         const isExpanding = !buttonElement.classList.contains('all-expanded');
         
         if (isExpanding) {
-            // Expand all
             const oddsData = Cache.get('odds', raceNum);
             
-            // First, expand UI immediately for all runners
+            // Expand UI immediately for all runners
             const runners = runnerRows.map(row => {
-                const params = row.getAttribute('onclick').match(/'([^']+)'/g).map(s => s.replace(/'/g, ''));
-                const horseNo = params[1];
-                const runnerNo = row.querySelector('.odds-win')?.getAttribute('data-horse') || horseNo;
-                const detailsRow = document.getElementById(`runner-details-${raceNum}-${horseNo}`);
-                const detailsContent = document.getElementById(`runner-details-content-${raceNum}-${horseNo}`);
-                const cacheKey = `${raceNum}-${horseNo}`;
+                const runnerData = Utils.getRunnerData(row);
+                const cacheKey = `${raceNum}-${runnerData.horseNo}`;
+                const detailsRow = document.getElementById(`runner-details-${raceNum}-${runnerData.horseNo}`);
+                const detailsContent = document.getElementById(`runner-details-content-${raceNum}-${runnerData.horseNo}`);
                 
-                // Expand UI
                 detailsRow.classList.add('expanded');
                 row.querySelector('.expand-icon').classList.add('expanded');
                 
-                // Show initial state
                 if (Cache.has('runnerDetails', cacheKey)) {
                     const historyHtml = Cache.get('runnerDetails', cacheKey);
-                    detailsContent.innerHTML = this.createContent(raceNum, runnerNo, horseNo, oddsData, historyHtml);
+                    detailsContent.innerHTML = this.createContent(raceNum, runnerData.runnerNo, runnerData.horseNo, oddsData, historyHtml);
                 } else {
                     detailsContent.innerHTML = this.createContent(
-                        raceNum, runnerNo, horseNo, oddsData,
+                        raceNum, runnerData.runnerNo, runnerData.horseNo, oddsData,
                         '<div class="details-loading">Loading race history...</div>'
                     );
                 }
                 
-                return { horseNo, runnerNo, params, detailsContent, cacheKey, detailsRow };
+                return runnerData;
             });
             
-            // Update button state immediately after expanding UI
             UI.updateExpandAllButtonState(raceNum);
             
-            // Load uncached histories sequentially in background
+            // Load uncached histories in background
             (async () => {
-                for (const runner of runners) {
-                    // Check if still expanded before loading
-                    if (!runner.detailsRow.classList.contains('expanded')) {
-                        continue; // Skip if user collapsed this runner
-                    }
-                    
-                    if (!Cache.has('runnerDetails', runner.cacheKey)) {
-                        try {
-                            const historyHtml = await this.load(
-                                raceNum,
-                                runner.horseNo,
-                                runner.params[2],
-                                runner.params[3],
-                                runner.params[4]
-                            );
-                            
-                            // Check again if still expanded after async load
-                            if (runner.detailsRow.classList.contains('expanded')) {
-                                const currentOddsData = Cache.get('odds', raceNum);
-                                runner.detailsContent.innerHTML = this.createContent(
-                                    raceNum, runner.runnerNo, runner.horseNo, currentOddsData, historyHtml
-                                );
-                            }
-                        } catch (error) {
-                            // Check if still expanded before showing error
-                            if (runner.detailsRow.classList.contains('expanded')) {
-                                const currentOddsData = Cache.get('odds', raceNum);
-                                runner.detailsContent.innerHTML = this.createContent(
-                                    raceNum, runner.runnerNo, runner.horseNo, currentOddsData,
-                                    `<div class="details-loading error">Error: ${error.message}</div>`
-                                );
-                            }
-                        }
-                    }
+                for (const runnerData of runners) {
+                    await this.loadRunnerData(raceNum, runnerData, oddsData);
                 }
             })();
         } else {
             // Collapse all
             runnerRows.forEach(row => {
-                const params = row.getAttribute('onclick').match(/'([^']+)'/g).map(s => s.replace(/'/g, ''));
-                const horseNo = params[1];
+                const horseNo = row.dataset.horse;
                 const detailsRow = document.getElementById(`runner-details-${raceNum}-${horseNo}`);
-                
                 detailsRow.classList.remove('expanded');
                 row.querySelector('.expand-icon').classList.remove('expanded');
             });
             
-            // Update button state immediately after collapsing
             UI.updateExpandAllButtonState(raceNum);
         }
+    },
+    
+    async prefetchAll() {
+        Utils.log('Starting background prefetch of runner histories...');
+        
+        const allRaces = Array.from(document.querySelectorAll('.race-content'));
+        if (allRaces.length === 0) return;
+        
+        for (const raceContent of allRaces) {
+            const raceNum = raceContent.id.replace('race-', '');
+            const runnerRows = Array.from(raceContent.querySelectorAll('.runner-row'));
+            
+            for (const row of runnerRows) {
+                const { horseNo, going, track, distance } = Utils.getRunnerData(row);
+                if (!horseNo) continue;
+                
+                const cacheKey = `${raceNum}-${horseNo}`;
+                if (Cache.has('runnerDetails', cacheKey)) continue;
+                
+                try {
+                    await this.load(raceNum, horseNo, going, track, distance);
+                    Utils.log(`✓ Prefetched race ${raceNum} - horse ${horseNo}`);
+                } catch (error) {
+                    console.error(`✗ Error prefetching race ${raceNum} - horse ${horseNo}:`, error);
+                }
+            }
+        }
+        
+        Utils.log('✓ Background prefetch completed');
     }
 };
 
@@ -524,36 +614,45 @@ const RunnerDetails = {
 // SPEEDMAP MODULE
 // ============================================================================
 const Speedmap = {
-    /**
-     * Load speedmap for a race
-     */
-    async load(raceNum) {
-    const speedmapImg = document.getElementById(`speedmap-${raceNum}`);
-    if (!speedmapImg) return;
+    ensureImageElement(raceNum, container) {
+        if (!container.querySelector('img')) {
+            container.innerHTML = `<img id="speedmap-${raceNum}" class="speedmap-image" alt="Race ${raceNum} Speed Map" />`;
+        }
+        return document.getElementById(`speedmap-${raceNum}`);
+    },
     
-        // Check cache first
+    async load(raceNum) {
+        const speedmapContainer = document.querySelector(`#race-${raceNum} .speedmap-container`);
+        const speedmapImg = document.getElementById(`speedmap-${raceNum}`);
+        if (!speedmapImg || !speedmapContainer) return;
+        
+        if (!RaceReadiness.isReady(raceNum)) {
+            speedmapImg.style.display = 'none';
+            speedmapContainer.innerHTML = '<div class="race-not-ready">Race not ready</div>';
+            return;
+        }
+        
         if (Cache.has('speedmaps', raceNum)) {
-            speedmapImg.src = Cache.get('speedmaps', raceNum);
-        speedmapImg.style.display = 'block';
-        return;
-    }
-    
-    speedmapImg.style.display = 'none';
-    
+            const img = this.ensureImageElement(raceNum, speedmapContainer);
+            img.src = Cache.get('speedmaps', raceNum);
+            img.style.display = 'block';
+            return;
+        }
+        
+        speedmapImg.style.display = 'none';
+        
         try {
             const base64String = await API.fetchSpeedmap(raceNum);
             Cache.set('speedmaps', raceNum, base64String);
-            speedmapImg.src = base64String;
-            speedmapImg.style.display = 'block';
+            const img = this.ensureImageElement(raceNum, speedmapContainer);
+            img.src = base64String;
+            img.style.display = 'block';
         } catch (error) {
             console.error(`Error loading speedmap for race ${raceNum}:`, error);
             speedmapImg.style.display = 'none';
         }
     },
     
-    /**
-     * Load all speedmaps sequentially via queue
-     */
     async loadAll() {
         const speedmapImages = document.querySelectorAll('.speedmap-image');
         for (const img of speedmapImages) {
@@ -567,24 +666,17 @@ const Speedmap = {
 // UI MODULE - User interface interactions
 // ============================================================================
 const UI = {
-    /**
-     * Show a specific race tab
-     */
     showRace(raceNum) {
         document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
         document.getElementById(`tab-${raceNum}`).classList.add('active');
         document.querySelectorAll('.race-content').forEach(content => content.classList.remove('active'));
         document.getElementById(`race-${raceNum}`).classList.add('active');
         
-        // Fetch odds if not cached
         if (!Cache.has('odds', raceNum)) {
             Odds.load(raceNum);
         }
     },
     
-    /**
-     * Update expand/collapse all button state
-     */
     updateExpandAllButtonState(raceNum) {
         const raceContent = document.getElementById(`race-${raceNum}`);
         const expandAllBtn = raceContent.querySelector('.expand-all-btn');
@@ -599,59 +691,53 @@ const UI = {
         }
     },
     
-    /**
-     * Sort table by column
-     */
     sortTable(raceNum, columnIndex, type) {
-    const table = document.querySelector(`#race-${raceNum} .runners-table`);
-    const tbody = table.querySelector('tbody');
-    const header = table.querySelectorAll('thead th')[columnIndex];
-    const allHeaders = table.querySelectorAll('thead th.sortable');
-    const rows = Array.from(tbody.querySelectorAll('tr')).filter((row, index) => index % 2 === 0);
-    const isAscending = !header.classList.contains('sort-asc');
-    
+        const table = document.querySelector(`#race-${raceNum} .runners-table`);
+        const tbody = table.querySelector('tbody');
+        const header = table.querySelectorAll('thead th')[columnIndex];
+        const allHeaders = table.querySelectorAll('thead th.sortable');
+        const rows = Array.from(tbody.querySelectorAll('tr')).filter((row, index) => index % 2 === 0);
+        const isAscending = !header.classList.contains('sort-asc');
+        
         // Reset all headers
-    allHeaders.forEach(h => {
-        h.classList.remove('sort-asc', 'sort-desc');
-        const arrow = h.querySelector('.sort-arrow');
-        if (arrow) arrow.textContent = '⇅';
-    });
-    
-        // Sort rows
-    rows.sort((a, b) => {
-        let aComp, bComp;
-        
-        if (type === 'number') {
-            aComp = parseFloat(a.cells[columnIndex].textContent.trim());
-            bComp = parseFloat(b.cells[columnIndex].textContent.trim());
-            if (isNaN(aComp)) aComp = -Infinity;
-            if (isNaN(bComp)) bComp = -Infinity;
-        } else {
-            aComp = a.cells[columnIndex].textContent.trim().toLowerCase();
-            bComp = b.cells[columnIndex].textContent.trim().toLowerCase();
-        }
+        allHeaders.forEach(h => {
+            h.classList.remove('sort-asc', 'sort-desc');
+            const arrow = h.querySelector('.sort-arrow');
+            if (arrow) arrow.textContent = '⇅';
+        });
         
+        // Sort rows
+        rows.sort((a, b) => {
+            let aComp, bComp;
+            
+            if (type === 'number') {
+                aComp = parseFloat(a.cells[columnIndex].textContent.trim());
+                bComp = parseFloat(b.cells[columnIndex].textContent.trim());
+                if (isNaN(aComp)) aComp = -Infinity;
+                if (isNaN(bComp)) bComp = -Infinity;
+            } else {
+                aComp = a.cells[columnIndex].textContent.trim().toLowerCase();
+                bComp = b.cells[columnIndex].textContent.trim().toLowerCase();
+            }
+            
             return isAscending ? 
                 (aComp > bComp ? 1 : aComp < bComp ? -1 : 0) : 
                 (aComp < bComp ? 1 : aComp > bComp ? -1 : 0);
-    });
-    
+        });
+        
         // Update header
-    header.classList.add(isAscending ? 'sort-asc' : 'sort-desc');
-    const arrow = header.querySelector('.sort-arrow');
-    if (arrow) arrow.textContent = isAscending ? '▲' : '▼';
-    
+        header.classList.add(isAscending ? 'sort-asc' : 'sort-desc');
+        const arrow = header.querySelector('.sort-arrow');
+        if (arrow) arrow.textContent = isAscending ? '▲' : '▼';
+        
         // Reorder rows
-    rows.forEach(row => {
+        rows.forEach(row => {
             const detailsRow = row.nextElementSibling;
-        tbody.appendChild(row);
+            tbody.appendChild(row);
             if (detailsRow) tbody.appendChild(detailsRow);
         });
     },
     
-    /**
-     * Open track workout video
-     */
     openTrackWorkoutVideo(raceDate, raceNum) {
         const dateParts = raceDate.split('-');
         const dateFormatted = dateParts.join('');
@@ -665,24 +751,18 @@ const UI = {
 // APPLICATION INITIALIZATION
 // ============================================================================
 const App = {
-    /**
-     * Initialize the application
-     */
     init() {
         console.log('Initializing HKJC Race Info...');
         
-        // Load speedmaps
         Speedmap.loadAll();
-        
-        // Start odds polling
         Odds.startPolling();
+        RunnerDetails.prefetchAll().catch(error => {
+            console.error('Error in background prefetch:', error);
+        });
         
         console.log('Application initialized successfully');
     },
     
-    /**
-     * Cleanup on page unload
-     */
     cleanup() {
         Odds.stopPolling();
         RequestQueue.clear();

{hkjc-0.3.21 → hkjc-0.3.22}/dashboard/static/styles.css

@@ -156,6 +156,14 @@ body {
     margin-top: -280px;
 }
 
+.race-not-ready {
+    padding: 20px;
+    color: #666;
+    font-size: 1em;
+    font-style: italic;
+    text-align: center;
+}
+
 .expand-all-container {
     margin-bottom: 10px;
 }
@@ -247,6 +255,11 @@ body {
     text-align: center;
     color: #667eea;
     font-size: 0.7em;
+    transition: transform 0.2s ease;
+}
+
+.expand-icon.expanded {
+    transform: rotate(90deg);
 }
 
 .runner-details-row {

{hkjc-0.3.21 → hkjc-0.3.22}/dashboard/templates/index.html

@@ -89,16 +89,17 @@
                         <th class="sortable" onclick="sortTable('{{ race_num }}', 9, 'number')">
                             Energy Diff <span class="sort-arrow">⇅</span>
                         </th>
-                        <th class="sortable" onclick="sortTable('{{ race_num }}', 10, 'number')">
+                        <th>Fav Style</th>
+                        <th class="sortable" onclick="sortTable('{{ race_num }}', 11, 'number')">
                             WIN <span class="sort-arrow">⇅</span>
                         </th>
-                        <th class="sortable" onclick="sortTable('{{ race_num }}', 11, 'number')">
+                        <th class="sortable" onclick="sortTable('{{ race_num }}', 12, 'number')">
                             WIN (fit) <span class="sort-arrow">⇅</span>
                         </th>
-                        <th class="sortable" onclick="sortTable('{{ race_num }}', 12, 'number')">
+                        <th class="sortable" onclick="sortTable('{{ race_num }}', 13, 'number')">
                             PLA <span class="sort-arrow">⇅</span>
                         </th>
-                        <th class="sortable" onclick="sortTable('{{ race_num }}', 13, 'number')">
+                        <th class="sortable" onclick="sortTable('{{ race_num }}', 14, 'number')">
                             PLA (fit) <span class="sort-arrow">⇅</span>
                         </th>
                     </tr>
@@ -106,6 +107,11 @@
                 <tbody>
                     {% for runner in race.Runners %}
                     <tr class="runner-row" 
+                        data-race="{{ race_num }}"
+                        data-horse="{{ runner.HorseNo }}"
+                        data-going="{{ race.Going }}"
+                        data-track="{{ race.Track }}"
+                        data-dist="{{ race.Dist }}"
                         onclick="toggleRunnerHistory(this, '{{ race_num }}', '{{ runner.HorseNo }}', '{{ race.Going }}', '{{ race.Track }}', '{{ race.Dist }}')">
                         <td>
                             <span class="expand-icon">▶</span>
@@ -122,13 +128,14 @@
                         <td>{{ runner.Rtg }}</td>
                         <td>{{ runner.Fitness }}</td>
                         <td>{{ runner.SPEnergy }}</td>
+                        <td class="fav-style" data-race="{{ race_num }}" data-horse="{{ runner.HorseNo }}">-</td>
                         <td class="odds-win" data-race="{{ race_num }}" data-horse="{{ runner.No }}">-</td>
                         <td class="odds-win-fit" data-race="{{ race_num }}" data-horse="{{ runner.No }}">-</td>
                         <td class="odds-pla" data-race="{{ race_num }}" data-horse="{{ runner.No }}">-</td>
                         <td class="odds-pla-fit" data-race="{{ race_num }}" data-horse="{{ runner.No }}">-</td>
                     </tr>
                     <tr class="runner-details-row" id="runner-details-{{ race_num }}-{{ runner.HorseNo }}">
-                        <td colspan="14" class="runner-details-cell">
+                        <td colspan="15" class="runner-details-cell">
                             <div class="runner-details-content" id="runner-details-content-{{ race_num }}-{{ runner.HorseNo }}">
                                 <div class="details-loading">Loading details...</div>
                             </div>

{hkjc-0.3.21 → hkjc-0.3.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hkjc"
-version = "0.3.21"
+version = "0.3.22"
 description = "Library for scrapping HKJC data and perform basic analysis"
 readme = "README.md"
 requires-python = ">=3.11"

{hkjc-0.3.21 → hkjc-0.3.22}/src/hkjc/historical.py

@@ -15,12 +15,21 @@ HKJC_HORSE_URL_TEMPLATE = "https://racing.hkjc.com/racing/information/English/Ho
 incidents = ['DISQ', 'DNF', 'FE', 'ML', 'PU', 'TNP', 'TO',
              'UR', 'VOID', 'WR', 'WV', 'WV-A', 'WX', 'WX-A', 'WXNR']
 
+REQUEST_TIMEOUT = 10
+
+HTML_HEADERS = {
+    "Origin": "https://racing.hkjc.com",
+    "Referer": "https://racing.hkjc.com",
+    "Content-Type": "text/plain",
+    "Accept": "*/*",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+}
 
 @ttl_cache(maxsize=100, ttl=3600)
 def _soupify(url: str) -> BeautifulSoup:
     """Fetch and parse a webpage and return BeautifulSoup object
     """
-    response = requests.get(url, timeout=180)
+    response = requests.get(url, timeout=REQUEST_TIMEOUT, headers=HTML_HEADERS)
     response.raise_for_status()
     return BeautifulSoup(response.content, 'html.parser')
 
@@ -43,6 +52,9 @@ def _soupify_horse_page(horse_no: str) -> BeautifulSoup:
 def _classify_running_style(df: pl.DataFrame, running_pos_col="RunningPosition") -> pl.DataFrame:
     """Classify running style based on RunningPosition column
     """
+    if df.height == 0:
+        return df
+    
     # Split the RunningPosition column into separate columns and convert to integers
     df = df.with_columns(
         pl.col(running_pos_col)
@@ -77,9 +89,9 @@ def _extract_horse_data(horse_no: str) -> pl.DataFrame:
     table = soup.find('table', class_='bigborder')
     horse_data = _parse_html_table(table).filter(
         pl.col('Date') != '')  # Remove empty rows
-    horse_data = _classify_running_style(horse_data)
-
-    horse_data = horse_data.with_columns(pl.lit(horse_no).alias('HorseNo'))
+    if horse_data.height > 0:
+        horse_data = _classify_running_style(horse_data)
+        horse_data = horse_data.with_columns(pl.lit(horse_no).alias('HorseNo'))
 
     return horse_data
 
@@ -87,6 +99,9 @@ def _extract_horse_data(horse_no: str) -> pl.DataFrame:
 def _clean_horse_data(df: pl.DataFrame) -> pl.DataFrame:
     """ Clean and convert horse data to suitable data types
     """
+    if df.height == 0:
+        return df
+    
     df = df.with_columns(
         pl.col('Pla').str.split(' ').list.first().alias('Pla')
     ).filter(~pl.col('Pla').is_in(incidents))
@@ -105,7 +120,8 @@ def _clean_horse_data(df: pl.DataFrame) -> pl.DataFrame:
           .with_columns(
         (
             pl.col("FinishTime").str.splitn(".", 2).struct.field("field_0").cast(pl.Int64) * 60 +
-            pl.col("FinishTime").str.splitn(".", 2).struct.field("field_1").cast(pl.Float64)
+            pl.col("FinishTime").str.splitn(
+                ".", 2).struct.field("field_1").cast(pl.Float64)
         ).cast(pl.Float64).round(2).alias("FinishTime")
     ))
 
@@ -134,6 +150,9 @@ def get_horse_data(horse_no: str) -> pl.DataFrame:
 def _clean_race_data(df: pl.DataFrame) -> pl.DataFrame:
     """ Clean and convert horse data to suitable data types
     """
+    if df.height == 0:
+        return df
+    
     df = df.with_columns(
         pl.col('Pla').str.split(' ').list.first().alias('Pla')
     ).filter(~pl.col('Pla').is_in(incidents))
@@ -150,7 +169,8 @@ def _clean_race_data(df: pl.DataFrame) -> pl.DataFrame:
     df = df.with_columns(
         (
             pl.col("FinishTime").str.splitn(":", 2).struct.field("field_0").cast(pl.Int64) * 60 +
-            pl.col("FinishTime").str.splitn(":", 2).struct.field("field_1").cast(pl.Float64)
+            pl.col("FinishTime").str.splitn(
+                ":", 2).struct.field("field_1").cast(pl.Float64)
         ).cast(pl.Float64).round(2).alias("FinishTime")
     )
 

{hkjc-0.3.21 → hkjc-0.3.22}/src/hkjc/live.py

@@ -7,6 +7,8 @@ import requests
 from cachetools.func import ttl_cache
 import numpy as np
 
+from .utils import _try_int
+
 HKJC_LIVEODDS_ENDPOINT = "https://info.cld.hkjc.com/graphql/base/"
 
 RACEMTG_PAYLOAD = {
@@ -241,25 +243,29 @@ query racing($date: String, $venueCode: String, $oddsTypes: [OddsType], $raceNo:
 }""",
 }
 
+JSON_HEADERS = {
+    "Origin": "https://bet.hkjc.com",
+    "Referer": "https://bet.hkjc.com",
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+}
+
+REQUEST_TIMEOUT = 30
+
 
 @ttl_cache(maxsize=12, ttl=1000)
-def _fetch_live_races(date: str=None, venue_code: str=None) -> dict:
+def _fetch_live_races(date: str = None, venue_code: str = None) -> dict:
     """Fetch live race data from HKJC GraphQL endpoint."""
     payload = RACEMTG_PAYLOAD.copy()
     payload["variables"] = payload["variables"].copy()
     payload["variables"]["date"] = date
     payload["variables"]["venueCode"] = venue_code
 
-    headers = {
-        "Origin": "https://bet.hkjc.com",
-        "Referer": "https://bet.hkjc.com",
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "User-Agent": "python-hkjc-fetch/0.1",
-    }
+    headers = JSON_HEADERS
 
     r = requests.post(HKJC_LIVEODDS_ENDPOINT, json=payload,
-                      headers=headers, timeout=10)
+                      headers=headers, timeout=REQUEST_TIMEOUT)
     if r.status_code != 200:
         raise RuntimeError(f"Request failed: {r.status_code} - {r.text}")
 
@@ -279,9 +285,9 @@ def _fetch_live_races(date: str=None, venue_code: str=None) -> dict:
         runners = [{'No': runner['no'],
                     'Name': runner['name_en'],
                     'Dr': runner['barrierDrawNumber'],
-                    'Rtg': int(runner['currentRating']),
-                    'Wt': int(runner['currentWeight']),
-                    'Handicap': int(runner['handicapWeight']),
+                    'Rtg': _try_int(runner['currentRating']),
+                    'Wt': _try_int(runner['currentWeight']),
+                    'Handicap': _try_int(runner['handicapWeight']),
                     'HorseNo': runner['horse']['code']
                     } for runner in race['runners'] if runner['status'] != "Standby"]
         race_info['Races'][race_num] = {
@@ -307,16 +313,10 @@ def _fetch_live_odds(date: str, venue_code: str, race_number: int, odds_type: Tu
     payload["variables"]["raceNo"] = race_number
     payload["variables"]["oddsTypes"] = odds_type
 
-    headers = {
-        "Origin": "https://bet.hkjc.com",
-        "Referer": "https://bet.hkjc.com",
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "User-Agent": "python-hkjc-fetch/0.1",
-    }
+    headers = JSON_HEADERS
 
     r = requests.post(HKJC_LIVEODDS_ENDPOINT, json=payload,
-                      headers=headers, timeout=10)
+                      headers=headers, timeout=REQUEST_TIMEOUT)
     if r.status_code != 200:
         raise RuntimeError(f"Request failed: {r.status_code} - {r.text}")
 
@@ -354,7 +354,8 @@ def live_odds(date: str, venue_code: str, race_number: int, odds_type: List[str]
     N = len(race_info['Races'][race_number]['Runners'])
 
     if (race_info['Date'] != date) or (race_info['Venue'] != venue_code):
-        print(f"[WARNING] Requested {date} {venue_code} but server returned {race_info['Date']} {race_info['Venue']}.")
+        print(
+            f"[WARNING] Requested {date} {venue_code} but server returned {race_info['Date']} {race_info['Venue']}.")
         date = race_info['Date']
         venue_code = race_info['Venue']
 

{hkjc-0.3.21 → hkjc-0.3.22}/src/hkjc/utils.py

@@ -4,6 +4,12 @@ from datetime import datetime as dt
 import bs4
 import re
 
+def _try_int(value: str) -> int:
+    try:
+        return int(value)
+    except:
+        return 0
+    
 
 def _validate_date(date_str: str) -> bool:
     # validate date format

{hkjc-0.3.21 → hkjc-0.3.22}/uv.lock

@@ -148,7 +148,7 @@ wheels = [
 
 [[package]]
 name = "hkjc"
-version = "0.3.21"
+version = "0.3.22"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },