GameSentenceMiner 2.18.14__py3-none-any.whl → 2.18.16__py3-none-any.whl

GameSentenceMiner/web/static/js/stats.js

@@ -527,6 +527,301 @@ document.addEventListener('DOMContentLoaded', function () {
         return `Speed: ${charsPerHour.toLocaleString()} chars/hour`;
     }
 
+    // Function to create hourly activity bar chart
+    function createHourlyActivityChart(canvasId, hourlyData) {
+        const canvas = document.getElementById(canvasId);
+        if (!canvas || !hourlyData || !Array.isArray(hourlyData)) return null;
+        
+        const ctx = canvas.getContext('2d');
+        
+        // Destroy existing chart if it exists
+        if (window.myCharts[canvasId]) {
+            window.myCharts[canvasId].destroy();
+        }
+        
+        // Create hour labels (0-23)
+        const hourLabels = [];
+        for (let i = 0; i < 24; i++) {
+            const hour12 = i === 0 ? 12 : i > 12 ? i - 12 : i;
+            const ampm = i < 12 ? 'AM' : 'PM';
+            hourLabels.push(`${hour12}${ampm}`);
+        }
+        
+        // Generate gradient colors for bars based on activity values
+        const maxActivity = Math.max(...hourlyData.filter(activity => activity > 0));
+        const minActivity = Math.min(...hourlyData.filter(activity => activity > 0));
+        
+        const barColors = hourlyData.map(activity => {
+            if (activity === 0) {
+                return getCurrentTheme() === 'dark' ? 'rgba(100, 100, 100, 0.3)' : 'rgba(200, 200, 200, 0.3)';
+            }
+            
+            // Create color gradient from red (low activity) to green (high activity)
+            const normalizedActivity = maxActivity > minActivity ? (activity - minActivity) / (maxActivity - minActivity) : 0.5;
+            const hue = normalizedActivity * 120; // 0 = red, 120 = green
+            return `hsla(${hue}, 70%, 50%, 0.8)`;
+        });
+        
+        const borderColors = hourlyData.map(activity => {
+            if (activity === 0) {
+                return getCurrentTheme() === 'dark' ? 'rgba(100, 100, 100, 0.6)' : 'rgba(200, 200, 200, 0.6)';
+            }
+            
+            const normalizedActivity = maxActivity > minActivity ? (activity - minActivity) / (maxActivity - minActivity) : 0.5;
+            const hue = normalizedActivity * 120;
+            return `hsla(${hue}, 70%, 40%, 1)`;
+        });
+
+        window.myCharts[canvasId] = new Chart(ctx, {
+            type: 'bar',
+            data: {
+                labels: hourLabels,
+                datasets: [{
+                    label: 'Characters Read',
+                    data: hourlyData,
+                    backgroundColor: barColors,
+                    borderColor: borderColors,
+                    borderWidth: 2
+                }]
+            },
+            options: {
+                responsive: true,
+                plugins: {
+                    legend: {
+                        display: false // Hide legend for cleaner look
+                    },
+                    title: {
+                        display: true,
+                        text: 'Reading Activity by Hour of Day',
+                        color: getThemeTextColor(),
+                        font: {
+                            size: 16,
+                            weight: 'bold'
+                        },
+                        padding: {
+                            top: 10,
+                            bottom: 20
+                        }
+                    },
+                    tooltip: {
+                        callbacks: {
+                            title: function(context) {
+                                const hourIndex = context[0].dataIndex;
+                                const hour24 = hourIndex;
+                                const hour12 = hour24 === 0 ? 12 : hour24 > 12 ? hour24 - 12 : hour24;
+                                const ampm = hour24 < 12 ? 'AM' : 'PM';
+                                return `${hour12}:00 ${ampm} (${hour24}:00)`;
+                            },
+                            label: function(context) {
+                                const activity = context.parsed.y;
+                                if (activity === 0) {
+                                    return 'No reading activity';
+                                }
+                                return `Characters: ${activity.toLocaleString()}`;
+                            },
+                            afterLabel: function(context) {
+                                const activity = context.parsed.y;
+                                if (activity === 0) return '';
+                                
+                                const total = hourlyData.reduce((sum, val) => sum + val, 0);
+                                const percentage = total > 0 ? ((activity / total) * 100).toFixed(1) : '0.0';
+                                return `${percentage}% of total activity`;
+                            }
+                        },
+                        backgroundColor: 'rgba(0, 0, 0, 0.9)',
+                        titleColor: '#fff',
+                        bodyColor: '#fff',
+                        borderColor: 'rgba(255, 255, 255, 0.2)',
+                        borderWidth: 1,
+                        cornerRadius: 8,
+                        displayColors: true
+                    }
+                },
+                scales: {
+                    y: {
+                        beginAtZero: true,
+                        title: {
+                            display: true,
+                            text: 'Characters Read',
+                            color: getThemeTextColor()
+                        },
+                        ticks: {
+                            color: getThemeTextColor(),
+                            callback: function(value) {
+                                return value.toLocaleString();
+                            }
+                        }
+                    },
+                    x: {
+                        title: {
+                            display: true,
+                            text: 'Hour of Day',
+                            color: getThemeTextColor()
+                        },
+                        ticks: {
+                            color: getThemeTextColor()
+                        }
+                    }
+                },
+                animation: {
+                    duration: 1000,
+                    easing: 'easeOutQuart'
+                }
+            }
+        });
+        
+        return window.myCharts[canvasId];
+    }
+
+    // Function to create hourly reading speed bar chart
+    function createHourlyReadingSpeedChart(canvasId, hourlySpeedData) {
+        const canvas = document.getElementById(canvasId);
+        if (!canvas || !hourlySpeedData || !Array.isArray(hourlySpeedData)) return null;
+        
+        const ctx = canvas.getContext('2d');
+        
+        // Destroy existing chart if it exists
+        if (window.myCharts[canvasId]) {
+            window.myCharts[canvasId].destroy();
+        }
+        
+        // Create hour labels (0-23)
+        const hourLabels = [];
+        for (let i = 0; i < 24; i++) {
+            const hour12 = i === 0 ? 12 : i > 12 ? i - 12 : i;
+            const ampm = i < 12 ? 'AM' : 'PM';
+            hourLabels.push(`${hour12}${ampm}`);
+        }
+        
+        // Generate gradient colors for bars based on speed values
+        const maxSpeed = Math.max(...hourlySpeedData.filter(speed => speed > 0));
+        const minSpeed = Math.min(...hourlySpeedData.filter(speed => speed > 0));
+        
+        const barColors = hourlySpeedData.map(speed => {
+            if (speed === 0) {
+                return getCurrentTheme() === 'dark' ? 'rgba(100, 100, 100, 0.3)' : 'rgba(200, 200, 200, 0.3)';
+            }
+            
+            // Create color gradient from red (slow) to green (fast)
+            const normalizedSpeed = maxSpeed > minSpeed ? (speed - minSpeed) / (maxSpeed - minSpeed) : 0.5;
+            const hue = normalizedSpeed * 120; // 0 = red, 120 = green
+            return `hsla(${hue}, 70%, 50%, 0.8)`;
+        });
+        
+        const borderColors = hourlySpeedData.map(speed => {
+            if (speed === 0) {
+                return getCurrentTheme() === 'dark' ? 'rgba(100, 100, 100, 0.6)' : 'rgba(200, 200, 200, 0.6)';
+            }
+            
+            const normalizedSpeed = maxSpeed > minSpeed ? (speed - minSpeed) / (maxSpeed - minSpeed) : 0.5;
+            const hue = normalizedSpeed * 120;
+            return `hsla(${hue}, 70%, 40%, 1)`;
+        });
+
+        window.myCharts[canvasId] = new Chart(ctx, {
+            type: 'bar',
+            data: {
+                labels: hourLabels,
+                datasets: [{
+                    label: 'Average Reading Speed',
+                    data: hourlySpeedData,
+                    backgroundColor: barColors,
+                    borderColor: borderColors,
+                    borderWidth: 2
+                }]
+            },
+            options: {
+                responsive: true,
+                plugins: {
+                    legend: {
+                        display: false // Hide legend for cleaner look
+                    },
+                    title: {
+                        display: true,
+                        text: 'Average Reading Speed by Hour',
+                        color: getThemeTextColor(),
+                        font: {
+                            size: 16,
+                            weight: 'bold'
+                        },
+                        padding: {
+                            top: 10,
+                            bottom: 20
+                        }
+                    },
+                    tooltip: {
+                        callbacks: {
+                            title: function(context) {
+                                const hourIndex = context[0].dataIndex;
+                                const hour24 = hourIndex;
+                                const hour12 = hour24 === 0 ? 12 : hour24 > 12 ? hour24 - 12 : hour24;
+                                const ampm = hour24 < 12 ? 'AM' : 'PM';
+                                return `${hour12}:00 ${ampm} (${hour24}:00)`;
+                            },
+                            label: function(context) {
+                                const speed = context.parsed.y;
+                                if (speed === 0) {
+                                    return 'No reading activity';
+                                }
+                                return `Speed: ${speed.toLocaleString()} chars/hour`;
+                            },
+                            afterLabel: function(context) {
+                                const speed = context.parsed.y;
+                                if (speed === 0) return '';
+                                
+                                const nonZeroSpeeds = hourlySpeedData.filter(s => s > 0);
+                                const avgSpeed = nonZeroSpeeds.reduce((sum, s) => sum + s, 0) / nonZeroSpeeds.length;
+                                const comparison = speed > avgSpeed ? 'above' : speed < avgSpeed ? 'below' : 'at';
+                                const percentage = avgSpeed > 0 ? Math.abs(((speed - avgSpeed) / avgSpeed) * 100).toFixed(1) : '0';
+                                
+                                return `${percentage}% ${comparison} average`;
+                            }
+                        },
+                        backgroundColor: 'rgba(0, 0, 0, 0.9)',
+                        titleColor: '#fff',
+                        bodyColor: '#fff',
+                        borderColor: 'rgba(255, 255, 255, 0.2)',
+                        borderWidth: 1,
+                        cornerRadius: 8,
+                        displayColors: true
+                    }
+                },
+                scales: {
+                    y: {
+                        beginAtZero: true,
+                        title: {
+                            display: true,
+                            text: 'Characters per Hour',
+                            color: getThemeTextColor()
+                        },
+                        ticks: {
+                            color: getThemeTextColor(),
+                            callback: function(value) {
+                                return value.toLocaleString();
+                            }
+                        }
+                    },
+                    x: {
+                        title: {
+                            display: true,
+                            text: 'Hour of Day',
+                            color: getThemeTextColor()
+                        },
+                        ticks: {
+                            color: getThemeTextColor()
+                        }
+                    }
+                },
+                animation: {
+                    duration: 1000,
+                    easing: 'easeOutQuart'
+                }
+            }
+        });
+        
+        return window.myCharts[canvasId];
+    }
+
     // Initialize Kanji Grid Renderer (using shared component)
     const kanjiGridRenderer = new KanjiGridRenderer({
         containerSelector: '#kanjiGrid',
@@ -540,10 +835,70 @@ document.addEventListener('DOMContentLoaded', function () {
         kanjiGridRenderer.render(kanjiData);
     }
 
+    // Function to update peak statistics display
+    function updatePeakStatistics(peakDailyStats, peakSessionStats) {
+        // Helper function to format large numbers
+        function formatLargeNumber(num) {
+            if (num >= 1000000) {
+                return (num / 1000000).toFixed(1) + 'M';
+            } else if (num >= 1000) {
+                return (num / 1000).toFixed(1) + 'K';
+            } else {
+                return num.toString();
+            }
+        }
+
+        // Helper function to format time in human-readable format
+        function formatTimeHuman(hours) {
+            if (hours < 1) {
+                const minutes = Math.round(hours * 60);
+                return minutes + 'm';
+            } else if (hours < 24) {
+                const wholeHours = Math.floor(hours);
+                const minutes = Math.round((hours - wholeHours) * 60);
+                if (minutes > 0) {
+                    return wholeHours + 'h ' + minutes + 'm';
+                } else {
+                    return wholeHours + 'h';
+                }
+            } else {
+                const days = Math.floor(hours / 24);
+                const remainingHours = Math.floor(hours % 24);
+                if (remainingHours > 0) {
+                    return days + 'd ' + remainingHours + 'h';
+                } else {
+                    return days + 'd';
+                }
+            }
+        }
+
+        // Update the display elements
+        const maxDailyCharsEl = document.getElementById('maxDailyChars');
+        const maxDailyHoursEl = document.getElementById('maxDailyHours');
+        const longestSessionEl = document.getElementById('longestSession');
+        const maxSessionCharsEl = document.getElementById('maxSessionChars');
+
+        if (maxDailyCharsEl) {
+            maxDailyCharsEl.textContent = formatLargeNumber(peakDailyStats.max_daily_chars || 0);
+        }
+
+        if (maxDailyHoursEl) {
+            maxDailyHoursEl.textContent = formatTimeHuman(peakDailyStats.max_daily_hours || 0);
+        }
+
+        if (longestSessionEl) {
+            longestSessionEl.textContent = formatTimeHuman(peakSessionStats.longest_session_hours || 0);
+        }
+
+        if (maxSessionCharsEl) {
+            maxSessionCharsEl.textContent = formatLargeNumber(peakSessionStats.max_session_chars || 0);
+        }
+    }
+
     function showNoDataPopup() {
         const popup = document.getElementById("noDataPopup");
         if (popup) popup.classList.remove("hidden");
-    }   
+    }
 
     const closeNoDataPopup = document.getElementById("closeNoDataPopup");
     if (closeNoDataPopup) {
@@ -618,11 +973,26 @@ document.addEventListener('DOMContentLoaded', function () {
                     createGameBarChartWithCustomFormat('readingSpeedPerGameChart', data.readingSpeedPerGame, 'Reading Speed Improvement', 'Speed (chars/hour)', formatSpeed, true);
                 }
 
+                // Create hourly activity polar chart if data exists
+                if (data.hourlyActivityData) {
+                    createHourlyActivityChart('hourlyActivityChart', data.hourlyActivityData);
+                }
+
+                // Create hourly reading speed chart if data exists
+                if (data.hourlyReadingSpeedData) {
+                    createHourlyReadingSpeedChart('hourlyReadingSpeedChart', data.hourlyReadingSpeedData);
+                }
+
                 // Create kanji grid if data exists
                 if (data.kanjiGridData) {
                     createKanjiGrid(data.kanjiGridData);
                 }
 
+                // Update peak statistics if data exists
+                if (data.peakDailyStats && data.peakSessionStats) {
+                    updatePeakStatistics(data.peakDailyStats, data.peakSessionStats);
+                }
+
                 return data;
             })
             .catch(error => {

GameSentenceMiner/web/stats.py

@@ -139,6 +139,34 @@ def calculate_heatmap_data(all_lines, filter_year=None):
     return dict(heatmap_data)
 
 
+def calculate_mining_heatmap_data(all_lines, filter_year=None):
+    """
+    Calculate heatmap data for mining activity.
+    Counts lines where screenshot_in_anki OR audio_in_anki is not empty.
+    """
+    heatmap_data = defaultdict(lambda: defaultdict(int))
+    
+    for line in all_lines:
+        # Check if line has been mined (either screenshot or audio in Anki)
+        has_screenshot = line.screenshot_in_anki and line.screenshot_in_anki.strip()
+        has_audio = line.audio_in_anki and line.audio_in_anki.strip()
+        
+        if not (has_screenshot or has_audio):
+            continue  # Skip lines that haven't been mined
+            
+        date_obj = datetime.date.fromtimestamp(float(line.timestamp))
+        year = str(date_obj.year)
+        
+        # Filter by year if specified
+        if filter_year and year != filter_year:
+            continue
+            
+        date_str = date_obj.strftime('%Y-%m-%d')
+        heatmap_data[year][date_str] += 1  # Count mined lines, not characters
+    
+    return dict(heatmap_data)
+
+
 def calculate_total_chars_per_game(all_lines):
     """Calculate total characters read per game."""
     game_data = defaultdict(lambda: {'total_chars': 0, 'first_time': None})
@@ -515,6 +543,166 @@ def calculate_average_daily_reading_time(all_lines):
     
     return average_hours
 
+def calculate_hourly_activity(all_lines):
+    """
+    Calculate reading activity aggregated by hour of day (0-23).
+    Returns character count for each hour across all days.
+    """
+    if not all_lines:
+        return [0] * 24
+    
+    hourly_chars = [0] * 24
+    
+    for line in all_lines:
+        # Get hour from timestamp (0-23)
+        hour = datetime.datetime.fromtimestamp(float(line.timestamp)).hour
+        char_count = len(line.line_text) if line.line_text else 0
+        hourly_chars[hour] += char_count
+    
+    return hourly_chars
+
+def calculate_hourly_reading_speed(all_lines):
+    """
+    Calculate average reading speed (chars/hour) aggregated by hour of day (0-23).
+    Returns average reading speed for each hour across all days.
+    """
+    if not all_lines:
+        return [0] * 24
+    
+    # Group lines by hour and collect timestamps for each hour
+    hourly_data = defaultdict(lambda: {'chars': 0, 'timestamps': []})
+    
+    for line in all_lines:
+        hour = datetime.datetime.fromtimestamp(float(line.timestamp)).hour
+        char_count = len(line.line_text) if line.line_text else 0
+        
+        hourly_data[hour]['chars'] += char_count
+        hourly_data[hour]['timestamps'].append(float(line.timestamp))
+    
+    # Calculate average reading speed for each hour
+    hourly_speeds = [0] * 24
+    
+    for hour in range(24):
+        if hour in hourly_data and len(hourly_data[hour]['timestamps']) >= 2:
+            chars = hourly_data[hour]['chars']
+            timestamps = hourly_data[hour]['timestamps']
+            
+            # Calculate actual reading time for this hour across all days
+            reading_time_seconds = calculate_actual_reading_time(timestamps)
+            reading_time_hours = reading_time_seconds / 3600
+            
+            # Calculate speed (chars per hour)
+            if reading_time_hours > 0:
+                hourly_speeds[hour] = int(chars / reading_time_hours)
+    
+    return hourly_speeds
+
+def calculate_peak_daily_stats(all_lines):
+    """
+    Calculate peak daily statistics: most chars read in a day and most hours studied in a day.
+    
+    Args:
+        all_lines: List of game lines
+    
+    Returns:
+        dict: Dictionary containing max_daily_chars and max_daily_hours
+    """
+    if not all_lines:
+        return {
+            'max_daily_chars': 0,
+            'max_daily_hours': 0.0
+        }
+    
+    # Calculate daily reading time using existing function
+    daily_reading_time = calculate_daily_reading_time(all_lines)
+    
+    # Calculate daily character counts
+    daily_chars = defaultdict(int)
+    for line in all_lines:
+        date_str = datetime.date.fromtimestamp(float(line.timestamp)).strftime('%Y-%m-%d')
+        char_count = len(line.line_text) if line.line_text else 0
+        daily_chars[date_str] += char_count
+    
+    # Find maximums
+    max_daily_chars = max(daily_chars.values()) if daily_chars else 0
+    max_daily_hours = max(daily_reading_time.values()) if daily_reading_time else 0.0
+    
+    return {
+        'max_daily_chars': max_daily_chars,
+        'max_daily_hours': max_daily_hours
+    }
+
+def calculate_peak_session_stats(all_lines):
+    """
+    Calculate peak session statistics: longest session and most chars in a session.
+    
+    Args:
+        all_lines: List of game lines
+    
+    Returns:
+        dict: Dictionary containing longest_session_hours and max_session_chars
+    """
+    if not all_lines:
+        return {
+            'longest_session_hours': 0.0,
+            'max_session_chars': 0
+        }
+    
+    # Sort lines by timestamp
+    sorted_lines = sorted(all_lines, key=lambda line: float(line.timestamp))
+    
+    # Get session gap from config
+    session_gap = get_stats_config().session_gap_seconds
+    
+    # Group lines into sessions
+    sessions = []
+    current_session = []
+    
+    for line in sorted_lines:
+        if not current_session:
+            current_session = [line]
+        else:
+            # Check if this line belongs to the current session
+            time_gap = float(line.timestamp) - float(current_session[-1].timestamp)
+            if time_gap <= session_gap:
+                current_session.append(line)
+            else:
+                # Start a new session
+                if current_session:
+                    sessions.append(current_session)
+                current_session = [line]
+    
+    # Don't forget the last session
+    if current_session:
+        sessions.append(current_session)
+    
+    # Calculate session statistics
+    longest_session_hours = 0.0
+    max_session_chars = 0
+    
+    for session in sessions:
+        if len(session) >= 2:
+            # Calculate session duration using actual reading time
+            timestamps = [float(line.timestamp) for line in session]
+            session_time_seconds = calculate_actual_reading_time(timestamps)
+            session_hours = session_time_seconds / 3600
+            
+            # Calculate session character count
+            session_chars = sum(len(line.line_text) if line.line_text else 0 for line in session)
+            
+            # Update maximums
+            longest_session_hours = max(longest_session_hours, session_hours)
+            max_session_chars = max(max_session_chars, session_chars)
+        elif len(session) == 1:
+            # Single line session - count characters but no time
+            session_chars = len(session[0].line_text) if session[0].line_text else 0
+            max_session_chars = max(max_session_chars, session_chars)
+    
+    return {
+        'longest_session_hours': longest_session_hours,
+        'max_session_chars': max_session_chars
+    }
+
 def calculate_all_games_stats(all_lines):
     """Calculate aggregate statistics for all games combined."""
     if not all_lines: