GameSentenceMiner 2.16.5__py3-none-any.whl → 2.16.7__py3-none-any.whl

GameSentenceMiner/web/static/js/stats.js

@@ -451,6 +451,28 @@ document.addEventListener('DOMContentLoaded', function () {
         return colors;
     }
 
+    // Helper function to filter chart data for visible bars
+    function getFilteredChartData(originalData, hiddenBars, colors) {
+        // Filter data to only include visible bars
+        const visibleLabels = [];
+        const visibleTotals = [];
+        const visibleColors = [];
+
+        originalData.labels.forEach((label, index) => {
+            if (!hiddenBars[index]) {
+                visibleLabels.push(label);
+                visibleTotals.push(originalData.totals[index]);
+                visibleColors.push(colors[index]);
+            }
+        });
+
+        return {
+            labels: visibleLabels,
+            totals: visibleTotals,
+            colors: visibleColors
+        };
+    }
+
     // Reusable function to create game bar charts with interactive legend
     function createGameBarChart(canvasId, chartData, chartTitle, yAxisLabel) {
         const ctx = document.getElementById(canvasId).getContext('2d');
@@ -459,6 +481,16 @@ document.addEventListener('DOMContentLoaded', function () {
         // Track which bars are hidden for toggle functionality
         const hiddenBars = new Array(chartData.labels.length).fill(false);
         
+        // Store original data for filtering
+        const originalData = {
+            labels: [...chartData.labels],
+            totals: [...chartData.totals]
+        };
+        
+        function updateChartData() {
+            return getFilteredChartData(originalData, hiddenBars, colors);
+        }
+        
         new Chart(ctx, {
             type: 'bar',
             data: {
@@ -483,8 +515,8 @@ document.addEventListener('DOMContentLoaded', function () {
                         labels: {
                             color: getThemeTextColor(),
                             generateLabels: function(chart) {
-                                // Create custom legend items for each game
-                                return chartData.labels.map((gameName, index) => ({
+                                // Create custom legend items for each game using original data
+                                return originalData.labels.map((gameName, index) => ({
                                     text: gameName,
                                     fillStyle: colors[index],
                                     strokeStyle: colors[index],
@@ -498,19 +530,18 @@ document.addEventListener('DOMContentLoaded', function () {
                         onClick: function(e, legendItem) {
                             const index = legendItem.index;
                             const chart = this.chart;
-                            const meta = chart.getDatasetMeta(0);
                             
                             // Toggle visibility for this specific bar
                             hiddenBars[index] = !hiddenBars[index];
                             
-                            // Update the dataset to hide/show this bar
-                            if (hiddenBars[index]) {
-                                meta.data[index].hidden = true;
-                            } else {
-                                meta.data[index].hidden = false;
-                            }
+                            // Update chart with filtered data
+                            const filteredData = updateChartData();
+                            chart.data.labels = filteredData.labels;
+                            chart.data.datasets[0].data = filteredData.totals;
+                            chart.data.datasets[0].backgroundColor = filteredData.colors.map(color => color + '99');
+                            chart.data.datasets[0].borderColor = filteredData.colors;
                             
-                            chart.update();
+                            chart.update('resize');
                         }
                     },
                     title: {
@@ -571,6 +602,16 @@ document.addEventListener('DOMContentLoaded', function () {
         // Track which bars are hidden for toggle functionality
         const hiddenBars = new Array(chartData.labels.length).fill(false);
         
+        // Store original data for filtering
+        const originalData = {
+            labels: [...chartData.labels],
+            totals: [...chartData.totals]
+        };
+        
+        function updateChartData() {
+            return getFilteredChartData(originalData, hiddenBars, colors);
+        }
+        
         new Chart(ctx, {
             type: 'bar',
             data: {
@@ -595,8 +636,8 @@ document.addEventListener('DOMContentLoaded', function () {
                         labels: {
                             color: getThemeTextColor(),
                             generateLabels: function(chart) {
-                                // Create custom legend items for each game
-                                return chartData.labels.map((gameName, index) => ({
+                                // Create custom legend items for each game using original data
+                                return originalData.labels.map((gameName, index) => ({
                                     text: gameName,
                                     fillStyle: colors[index],
                                     strokeStyle: colors[index],
@@ -610,19 +651,18 @@ document.addEventListener('DOMContentLoaded', function () {
                         onClick: function(e, legendItem) {
                             const index = legendItem.index;
                             const chart = this.chart;
-                            const meta = chart.getDatasetMeta(0);
                             
                             // Toggle visibility for this specific bar
                             hiddenBars[index] = !hiddenBars[index];
                             
-                            // Update the dataset to hide/show this bar
-                            if (hiddenBars[index]) {
-                                meta.data[index].hidden = true;
-                            } else {
-                                meta.data[index].hidden = false;
-                            }
+                            // Update chart with filtered data
+                            const filteredData = updateChartData();
+                            chart.data.labels = filteredData.labels;
+                            chart.data.datasets[0].data = filteredData.totals;
+                            chart.data.datasets[0].backgroundColor = filteredData.colors.map(color => color + '99');
+                            chart.data.datasets[0].borderColor = filteredData.colors;
                             
-                            chart.update();
+                            chart.update('resize');
                         }
                     },
                     title: {
@@ -777,6 +817,12 @@ document.addEventListener('DOMContentLoaded', function () {
                     window.dashboardInitialized = true;
                 }
 
+                // Load goal progress chart (always refresh)
+                if (typeof loadGoalProgress === 'function') {
+                    // Use the current data instead of making another API call
+                    updateGoalProgressWithData(data);
+                }
+
                 return data;
             })
             .catch(error => {
@@ -786,13 +832,310 @@ document.addEventListener('DOMContentLoaded', function () {
             });
     }
 
+    // Goal Progress Chart functionality
+    let goalSettings = {
+        reading_hours_target: 1500,
+        character_count_target: 25000000,
+        games_target: 100
+    };
+
+    // Function to load goal settings from API
+    async function loadGoalSettings() {
+        try {
+            const response = await fetch('/api/settings');
+            if (response.ok) {
+                const settings = await response.json();
+                goalSettings = {
+                    reading_hours_target: settings.reading_hours_target || 1500,
+                    character_count_target: settings.character_count_target || 25000000,
+                    games_target: settings.games_target || 100
+                };
+            }
+        } catch (error) {
+            console.error('Error loading goal settings:', error);
+        }
+    }
+
+    // Function to calculate 90-day rolling average for projections
+    function calculate90DayAverage(allLinesData, metricType) {
+        if (!allLinesData || allLinesData.length === 0) {
+            return 0;
+        }
+
+        const today = new Date();
+        const ninetyDaysAgo = new Date(today.getTime() - (90 * 24 * 60 * 60 * 1000));
+        
+        // Filter data to last 90 days
+        const recentData = allLinesData.filter(line => {
+            const lineDate = new Date(line.timestamp * 1000);
+            return lineDate >= ninetyDaysAgo && lineDate <= today;
+        });
+
+        if (recentData.length === 0) {
+            return 0;
+        }
+
+        let dailyTotals = {};
+        
+        if (metricType === 'hours') {
+            // Group by day and calculate reading time using AFK timer logic
+            const dailyTimestamps = {};
+            for (const line of recentData) {
+                const dateStr = new Date(line.timestamp * 1000).toISOString().split('T')[0];
+                if (!dailyTimestamps[dateStr]) {
+                    dailyTimestamps[dateStr] = [];
+                }
+                dailyTimestamps[dateStr].push(line.timestamp);
+            }
+            
+            for (const [dateStr, timestamps] of Object.entries(dailyTimestamps)) {
+                if (timestamps.length >= 2) {
+                    timestamps.sort((a, b) => a - b);
+                    let dayHours = 0;
+                    const afkTimerSeconds = 120; // Default AFK timer
+                    
+                    for (let i = 1; i < timestamps.length; i++) {
+                        const gap = timestamps[i] - timestamps[i-1];
+                        dayHours += Math.min(gap, afkTimerSeconds) / 3600;
+                    }
+                    dailyTotals[dateStr] = dayHours;
+                } else if (timestamps.length === 1) {
+                    dailyTotals[dateStr] = 1 / 3600; // Minimal activity
+                }
+            }
+        } else if (metricType === 'characters') {
+            // Group by day and sum characters
+            for (const line of recentData) {
+                const dateStr = new Date(line.timestamp * 1000).toISOString().split('T')[0];
+                dailyTotals[dateStr] = (dailyTotals[dateStr] || 0) + (line.characters || 0);
+            }
+        } else if (metricType === 'games') {
+            // Group by day and count unique games
+            const dailyGames = {};
+            for (const line of recentData) {
+                const dateStr = new Date(line.timestamp * 1000).toISOString().split('T')[0];
+                if (!dailyGames[dateStr]) {
+                    dailyGames[dateStr] = new Set();
+                }
+                dailyGames[dateStr].add(line.game_name);
+            }
+            
+            for (const [dateStr, gamesSet] of Object.entries(dailyGames)) {
+                dailyTotals[dateStr] = gamesSet.size;
+            }
+        }
+        
+        const totalDays = Object.keys(dailyTotals).length;
+        if (totalDays === 0) {
+            return 0;
+        }
+        
+        const totalValue = Object.values(dailyTotals).reduce((sum, value) => sum + value, 0);
+        return totalValue / totalDays;
+    }
+
+    // Function to format projection text
+    function formatProjection(currentValue, targetValue, dailyAverage, metricType) {
+        if (currentValue >= targetValue) {
+            return 'Goal achieved! 🎉';
+        }
+        
+        if (dailyAverage <= 0) {
+            return 'No recent activity';
+        }
+        
+        const remaining = targetValue - currentValue;
+        const daysToComplete = Math.ceil(remaining / dailyAverage);
+        
+        if (daysToComplete <= 0) {
+            return 'Goal achieved! 🎉';
+        } else if (daysToComplete === 1) {
+            return '~1 day remaining';
+        } else if (daysToComplete <= 7) {
+            return `~${daysToComplete} days remaining`;
+        } else if (daysToComplete <= 30) {
+            const weeks = Math.ceil(daysToComplete / 7);
+            return `~${weeks} week${weeks > 1 ? 's' : ''} remaining`;
+        } else if (daysToComplete <= 365) {
+            const months = Math.ceil(daysToComplete / 30);
+            return `~${months} month${months > 1 ? 's' : ''} remaining`;
+        } else {
+            const years = Math.ceil(daysToComplete / 365);
+            return `~${years} year${years > 1 ? 's' : ''} remaining`;
+        }
+    }
+
+    // Function to format large numbers
+    function formatGoalNumber(num) {
+        if (num >= 1000000) {
+            return (num / 1000000).toFixed(1) + 'M';
+        } else if (num >= 1000) {
+            return (num / 1000).toFixed(1) + 'K';
+        }
+        return num.toString();
+    }
+
+    // Function to update progress bar color based on percentage
+    function updateProgressBarColor(progressElement, percentage) {
+        // Remove existing completion classes
+        progressElement.classList.remove('completion-0', 'completion-25', 'completion-50', 'completion-75', 'completion-100');
+        
+        // Add appropriate class based on percentage
+        if (percentage >= 100) {
+            progressElement.classList.add('completion-100');
+        } else if (percentage >= 75) {
+            progressElement.classList.add('completion-75');
+        } else if (percentage >= 50) {
+            progressElement.classList.add('completion-50');
+        } else if (percentage >= 25) {
+            progressElement.classList.add('completion-25');
+        } else {
+            progressElement.classList.add('completion-0');
+        }
+    }
+
+    // Helper function to update goal progress UI with provided data
+    function updateGoalProgressUI(allGamesStats, allLinesData) {
+        if (!allGamesStats) {
+            throw new Error('No stats data available');
+        }
+        
+        // Calculate current progress
+        const currentHours = allGamesStats.total_time_hours || 0;
+        const currentCharacters = allGamesStats.total_characters || 0;
+        const currentGames = allGamesStats.unique_games || 0;
+        
+        // Calculate 90-day averages for projections
+        const dailyHoursAvg = calculate90DayAverage(allLinesData, 'hours');
+        const dailyCharsAvg = calculate90DayAverage(allLinesData, 'characters');
+        const dailyGamesAvg = calculate90DayAverage(allLinesData, 'games');
+        
+        // Update Hours Goal
+        const hoursPercentage = Math.min(100, (currentHours / goalSettings.reading_hours_target) * 100);
+        document.getElementById('goalHoursCurrent').textContent = Math.floor(currentHours).toLocaleString();
+        document.getElementById('goalHoursTarget').textContent = goalSettings.reading_hours_target.toLocaleString();
+        document.getElementById('goalHoursPercentage').textContent = Math.floor(hoursPercentage) + '%';
+        document.getElementById('goalHoursProjection').textContent =
+            formatProjection(currentHours, goalSettings.reading_hours_target, dailyHoursAvg, 'hours');
+        
+        const hoursProgressBar = document.getElementById('goalHoursProgress');
+        hoursProgressBar.style.width = hoursPercentage + '%';
+        hoursProgressBar.setAttribute('data-percentage', Math.floor(hoursPercentage / 25) * 25);
+        updateProgressBarColor(hoursProgressBar, hoursPercentage);
+        
+        // Update Characters Goal
+        const charsPercentage = Math.min(100, (currentCharacters / goalSettings.character_count_target) * 100);
+        document.getElementById('goalCharsCurrent').textContent = formatGoalNumber(currentCharacters);
+        document.getElementById('goalCharsTarget').textContent = formatGoalNumber(goalSettings.character_count_target);
+        document.getElementById('goalCharsPercentage').textContent = Math.floor(charsPercentage) + '%';
+        document.getElementById('goalCharsProjection').textContent =
+            formatProjection(currentCharacters, goalSettings.character_count_target, dailyCharsAvg, 'characters');
+            
+        const charsProgressBar = document.getElementById('goalCharsProgress');
+        charsProgressBar.style.width = charsPercentage + '%';
+        charsProgressBar.setAttribute('data-percentage', Math.floor(charsPercentage / 25) * 25);
+        updateProgressBarColor(charsProgressBar, charsPercentage);
+        
+        // Update Games Goal
+        const gamesPercentage = Math.min(100, (currentGames / goalSettings.games_target) * 100);
+        document.getElementById('goalGamesCurrent').textContent = currentGames.toLocaleString();
+        document.getElementById('goalGamesTarget').textContent = goalSettings.games_target.toLocaleString();
+        document.getElementById('goalGamesPercentage').textContent = Math.floor(gamesPercentage) + '%';
+        document.getElementById('goalGamesProjection').textContent =
+            formatProjection(currentGames, goalSettings.games_target, dailyGamesAvg, 'games');
+            
+        const gamesProgressBar = document.getElementById('goalGamesProgress');
+        gamesProgressBar.style.width = gamesPercentage + '%';
+        gamesProgressBar.setAttribute('data-percentage', Math.floor(gamesPercentage / 25) * 25);
+        updateProgressBarColor(gamesProgressBar, gamesPercentage);
+    }
+
+    // Main function to load and display goal progress
+    async function loadGoalProgress() {
+        const goalProgressChart = document.getElementById('goalProgressChart');
+        const goalProgressLoading = document.getElementById('goalProgressLoading');
+        const goalProgressError = document.getElementById('goalProgressError');
+        
+        if (!goalProgressChart) return;
+        
+        try {
+            // Show loading state
+            goalProgressLoading.style.display = 'flex';
+            goalProgressError.style.display = 'none';
+            
+            // Load goal settings and stats data
+            await loadGoalSettings();
+            const response = await fetch('/api/stats');
+            if (!response.ok) throw new Error('Failed to fetch stats data');
+            
+            const data = await response.json();
+            const allGamesStats = data.allGamesStats;
+            const allLinesData = data.allLinesData || [];
+            
+            // Update the UI using the shared helper function
+            updateGoalProgressUI(allGamesStats, allLinesData);
+            
+            // Hide loading state
+            goalProgressLoading.style.display = 'none';
+            
+        } catch (error) {
+            console.error('Error loading goal progress:', error);
+            goalProgressLoading.style.display = 'none';
+            goalProgressError.style.display = 'block';
+        }
+    }
+
     // Initial load with saved year preference
     const savedYear = localStorage.getItem('selectedHeatmapYear') || 'all';
     loadStatsData(savedYear);
 
+    // Function to update goal progress using existing stats data
+    async function updateGoalProgressWithData(statsData) {
+        const goalProgressChart = document.getElementById('goalProgressChart');
+        const goalProgressLoading = document.getElementById('goalProgressLoading');
+        const goalProgressError = document.getElementById('goalProgressError');
+        
+        if (!goalProgressChart) return;
+        
+        try {
+            // Load goal settings if not already loaded
+            if (!goalSettings.reading_hours_target) {
+                await loadGoalSettings();
+            }
+            
+            const allGamesStats = statsData.allGamesStats;
+            const allLinesData = statsData.allLinesData || [];
+            
+            // Update the UI using the shared helper function
+            updateGoalProgressUI(allGamesStats, allLinesData);
+            
+            // Hide loading and error states
+            goalProgressLoading.style.display = 'none';
+            goalProgressError.style.display = 'none';
+            
+        } catch (error) {
+            console.error('Error updating goal progress:', error);
+            goalProgressLoading.style.display = 'none';
+            goalProgressError.style.display = 'block';
+        }
+    }
+
+    // Load goal progress initially
+    setTimeout(() => {
+        loadGoalProgress();
+    }, 1000);
+    
+    // Refresh goal progress when settings are updated
+    window.addEventListener('settingsUpdated', () => {
+        setTimeout(() => {
+            loadGoalProgress();
+        }, 500);
+    });
+
     // Make functions globally available
     window.createHeatmap = createHeatmap;
     window.loadStatsData = loadStatsData;
+    window.loadGoalProgress = loadGoalProgress;
 
     // Dashboard functionality
     function loadDashboardData(data = null) {

GameSentenceMiner/web/stats.py

@@ -2,7 +2,7 @@ import datetime
 from collections import defaultdict
 
 from GameSentenceMiner.util.db import GameLinesTable
-from GameSentenceMiner.util.configuration import logger, get_config
+from GameSentenceMiner.util.configuration import get_stats_config, logger, get_config
 
 
 def is_kanji(char):
@@ -286,7 +286,7 @@ def calculate_actual_reading_time(timestamps, afk_timer_seconds=None):
         return 0.0
     
     if afk_timer_seconds is None:
-        afk_timer_seconds = get_config().advanced.afk_timer_seconds
+        afk_timer_seconds = get_stats_config().afk_timer_seconds
     
     # Sort timestamps to ensure chronological order
     sorted_timestamps = sorted(timestamps)
@@ -442,7 +442,7 @@ def calculate_current_game_stats(all_lines):
     sessions = 1
     for i in range(1, len(sorted_timestamps)):
         time_gap = sorted_timestamps[i] - sorted_timestamps[i-1]
-        if time_gap > get_config().advanced.session_gap_seconds:
+        if time_gap > get_stats_config().session_gap_seconds:
             sessions += 1
     
     # Calculate daily activity for progress trend

GameSentenceMiner/web/templates/search.html

@@ -40,7 +40,12 @@
                 autocomplete="off"
             />
         </div>
-        
+        <div class="regex-checkbox-container" style="margin-top: 8px;">
+            <label>
+                <input type="checkbox" id="regexCheckbox" />
+                Regex search
+            </label>
+        </div>
         <div class="search-filters">
             <div class="filter-group">
                 <label class="filter-label">Game:</label>