From b889d2199177ce7711031bc25b170e577efd5851 Mon Sep 17 00:00:00 2001
From: Justin Kleiber <jkleiber8@gmail.com>
Date: Wed, 22 May 2024 00:07:43 -0400
Subject: [PATCH] Adds SAUCE, BRIQUETTE, and RIBS to the website (#39)

* Adds the old stats to the website, but not to the ranking page yet

* Adds stats to the ranking view and adds some filtering

* Updates data scripts to avoid hanging and adds filtering for stats on the ranking page

* Adds shorter default timeout to github action jobs

* Mobile optimization to the event ranking table
---
 .github/workflows/update_data.yaml |   3 +
 src/components/EventDataRow.vue    |  27 +++-
 src/components/StatSummary.vue     |  12 +-
 src/components/TableHeader.vue     |  14 +-
 src/views/EventRankingsView.vue    | 247 +++++++++++++++++++++++++----
 src/views/EventView.vue            |  24 +++
 util/data_loader.py                |  10 +-
 util/event_processor.py            | 100 ++++++++++--
 util/main.py                       |   4 +-
 util/supabase_api.py               |  11 +-
 10 files changed, 398 insertions(+), 54 deletions(-)

diff --git a/.github/workflows/update_data.yaml b/.github/workflows/update_data.yaml
index 1e356d6..dc3f4bf 100644
--- a/.github/workflows/update_data.yaml
+++ b/.github/workflows/update_data.yaml
@@ -46,6 +46,7 @@ jobs:
     name: Load Blue Banners
     needs: set_up_environment
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     defaults:
       run:
         working-directory: ./util
@@ -74,6 +75,7 @@ jobs:
     name: Load Event Data
     needs: [set_up_environment, load_blue_banners]
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     defaults:
       run:
         working-directory: ./util
@@ -102,6 +104,7 @@ jobs:
     name: Load Team Data
     needs: [set_up_environment, load_blue_banners]
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     defaults:
       run:
         working-directory: ./util
diff --git a/src/components/EventDataRow.vue b/src/components/EventDataRow.vue
index cf0dce5..97deadb 100644
--- a/src/components/EventDataRow.vue
+++ b/src/components/EventDataRow.vue
@@ -9,8 +9,8 @@
         <td class="event-name-data">
             <a v-bind:href="eventLink">{{ year }} {{ name }}</a>
         </td>
-        <td v-for="stat in eventData">
-            {{ stat.value.toFixed(4) }}
+        <td v-for="stat in visibleData">
+            {{ valueDisplay(stat) }}
         </td>
     </tr>
 </template>
@@ -22,7 +22,8 @@ export default {
         name: null,
         year: null,
         eventId: null,
-        eventData: null
+        eventData: null,
+        columnData: null
     },
     computed: {
         rankNumberString() {
@@ -36,6 +37,26 @@ export default {
         },
         eventAvailable() {
             return this.eventId != null && this.eventData != null;
+        },
+        visibleData() {
+            // Default to showing all columns.
+            let data = this.eventData;
+
+            // If column data is provided, only show the visible columns based on name matching.
+            if (this.columnData) {
+                let cols = this.columnData.filter((col) => col.visible == true);
+                let colNames = cols.map(({ name }) => name);
+                data = this.eventData.filter((item) => colNames.includes(item.name));
+            }
+            return data;
+        }
+    },
+    methods: {
+        valueDisplay(stat) {
+            if (stat && stat.value) {
+                return stat.value.toFixed(4);
+            }
+            return "N/A";
         }
     }
 }
diff --git a/src/components/StatSummary.vue b/src/components/StatSummary.vue
index b9c196f..9d07acf 100644
--- a/src/components/StatSummary.vue
+++ b/src/components/StatSummary.vue
@@ -16,7 +16,7 @@ ChartJS.register(ArcElement, Tooltip, Legend, Colors, Title)
                 {{ stat.name }}
             </div>
             <div class="stat-value">
-                {{ stat.value.toFixed(4) }}
+                {{ valueDisplay(stat) }}
             </div>
         </div>
     </div>
@@ -108,6 +108,12 @@ export default {
         }
     },
     methods: {
+        valueDisplay(stat) {
+            if (stat && stat.value) {
+                return stat.value.toFixed(4);
+            }
+            return "N/A";
+        },
         convertDictToSortedValueArray(dict) {
             var items = Object.keys(dict).map(function (key) {
                 return [key, dict[key]];
@@ -202,8 +208,8 @@ export default {
 }
 
 .stat-cell {
-    max-width: 250px;
-    min-width: 100px;
+    width: 250px;
+    min-width: 25%;
     margin: 0 auto;
 }
 
diff --git a/src/components/TableHeader.vue b/src/components/TableHeader.vue
index 4ead8ee..4366d88 100644
--- a/src/components/TableHeader.vue
+++ b/src/components/TableHeader.vue
@@ -4,7 +4,7 @@
 
 <template>
     <thead>
-        <th v-for="col, i in columnData" :class="headerClass(col, i)" @click="sortIfSortable(col, i)">
+        <th v-for="col, i in visibleColumns" :class="headerClass(col, i)" @click="sortIfSortable(col, i)">
             {{ col.name }}
         </th>
     </thead>
@@ -16,6 +16,12 @@ export default {
         columnData: null,
         sortedColumnIndex: -1
     },
+    computed: {
+        visibleColumns() {
+            let cols = this.columnData.filter(col => col.visible == true);
+            return cols;
+        }
+    },
     methods: {
         headerClass(col, idx) {
             if (Object.keys(col).includes('sortable')
@@ -38,6 +44,12 @@ export default {
 </script>
 
 <style scoped>
+table th {
+    position: sticky;
+    top: 0px;
+    background: var(--bbq-background-color);
+}
+
 .stat-row {
     display: flex;
     flex-direction: row;
diff --git a/src/views/EventRankingsView.vue b/src/views/EventRankingsView.vue
index 5c1cc2b..15f95d9 100644
--- a/src/views/EventRankingsView.vue
+++ b/src/views/EventRankingsView.vue
@@ -8,6 +8,7 @@ import EventDataRow from '@/components/EventDataRow.vue';
 
 import '@material/web/select/outlined-select';
 import '@material/web/select/select-option';
+import '@material/web/chips/filter-chip';
 
 </script>
 
@@ -16,12 +17,46 @@ import '@material/web/select/select-option';
     <div class="main-content">
         <!-- Filters -->
         <div class="filter-container">
-            <md-outlined-select class="filter-select">
-                <md-select-option v-for="filter, idx in yearFilters" v-bind:selected="idx == curYearIndex"
-                    v-bind:aria-label="filter" @click="setActiveYearFilter(idx)">
-                    <div slot="headline">{{ filter }}</div>
-                </md-select-option>
-            </md-outlined-select>
+            <div class="filter-options">
+                <h3>Year Range</h3>
+                <md-outlined-select class="filter-select" v-bind:display-text="lowerYearDisplay">
+                    <md-select-option v-for="filter, idx in lowerYearFilters" v-bind:selected="idx == lowerYearIndex"
+                        :key="idx" :ref="lowerYearIndex" v-bind:aria-label="filter" @click="setLowerYearFilter(idx)">
+                        <div slot="headline">{{ filter }}</div>
+                    </md-select-option>
+                </md-outlined-select>
+                to
+                <md-outlined-select class="filter-select" v-bind:display-text="upperYearDisplay">
+                    <md-select-option v-for="filter, idx in upperYearFilters" v-bind:selected="idx == upperYearIndex"
+                        v-bind:aria-label="filter" @click="setUpperYearFilter(idx)">
+                        <div slot="headline">{{ filter }}</div>
+                    </md-select-option>
+                </md-outlined-select>
+            </div>
+
+            <div class="filter-options" style="min-width: 120px">
+                <h3>Statistics</h3>
+                <md-chip-set class="vertical-chip-set">
+                    <md-filter-chip label="BBQ" @click="toggleStatFilter('bbq')" v-bind:selected="getStatChipStatus('bbq')"
+                        class="vertical-chip-set-chip"></md-filter-chip>
+                    <md-filter-chip label="SAUCE" @click="toggleStatFilter('sauce')"
+                        v-bind:selected="getStatChipStatus('sauce')" class="vertical-chip-set-chip"></md-filter-chip>
+                    <md-filter-chip label="BRIQUETTE" @click="toggleStatFilter('briquette')"
+                        v-bind:selected="getStatChipStatus('briquette')" class="vertical-chip-set-chip"></md-filter-chip>
+                    <md-filter-chip label="RIBS" @click="toggleStatFilter('ribs')"
+                        v-bind:selected="getStatChipStatus('ribs')" class="vertical-chip-set-chip"></md-filter-chip>
+                </md-chip-set>
+            </div>
+
+            <div class="filter-options" style="min-width: 141px">
+                <h3>Award Types</h3>
+                <md-chip-set class="vertical-chip-set">
+                    <md-filter-chip label="Robot" @click="toggleTypeFilter('robot')"
+                        v-bind:selected="getTypeChipStatus('robot')" class="vertical-chip-set-chip"></md-filter-chip>
+                    <md-filter-chip label="Team Attribute" @click="toggleTypeFilter('team')"
+                        v-bind:selected="getTypeChipStatus('team')" class="vertical-chip-set-chip"></md-filter-chip>
+                </md-chip-set>
+            </div>
         </div>
 
         <!-- Rankings -->
@@ -29,8 +64,11 @@ import '@material/web/select/select-option';
             <table>
                 <TableHeader :column-data="tableColumns" :sorted-column-index="sortedColumnIdx" @sort="sortColumn">
                 </TableHeader>
-                <EventDataRow v-for="event, rank in eventList" :rank="rank + 1" :event-id="event.event_id"
-                    :name="event.name" :year="event.year" :event-data="event.event_data"></EventDataRow>
+                <tbody class="scrollable-table-body">
+                    <EventDataRow v-for="event, rank in eventList" :rank="rank + 1" :event-id="event.event_id"
+                        :name="event.name" :year="event.year" :event-data="event.event_data" :column-data="tableColumns">
+                    </EventDataRow>
+                </tbody>
             </table>
         </div>
         <div v-else-if="loadingEvents && eventList.length == 0">
@@ -51,24 +89,63 @@ export default {
             loadingEvents: false,
             eventList: [],
             tableColumns: [
-                { "name": "Rank" },
-                { "name": "Event Name" },
-                { "name": "Robot BBQ", "sortable": true, "db_col": "robot_bbq" },
-                { "name": "Team Attribute BBQ", "sortable": true, "db_col": "team_bbq" }
+                { "name": "Rank", visible: true, stat: 'info', type: 'info' },
+                { "name": "Event Name", visible: true, stat: 'info', type: 'info' },
+                { "name": "Robot BBQ", "sortable": true, "db_col": "robot_bbq", visible: true, stat: 'bbq', type: 'robot' },
+                { "name": "Team Attribute BBQ", "sortable": true, "db_col": "team_bbq", visible: true, stat: 'bbq', type: 'team' },
+                { "name": "Robot SAUCE", "sortable": true, "db_col": "robot_sauce", visible: true, stat: 'sauce', type: 'robot' },
+                { "name": "Team Attribute SAUCE", "sortable": true, "db_col": "team_sauce", visible: true, stat: 'sauce', type: 'team' },
+                { "name": "Robot BRIQUETTE", "sortable": true, "db_col": "robot_briquette", visible: true, stat: 'briquette', type: 'robot' },
+                { "name": "Team Attribute BRIQUETTE", "sortable": true, "db_col": "team_briquette", visible: true, stat: 'briquette', type: 'team' },
+                { "name": "Robot RIBS", "sortable": true, "db_col": "robot_ribs", visible: true, stat: 'ribs', type: 'robot' },
+                { "name": "Team Attribute RIBS", "sortable": true, "db_col": "team_ribs", visible: true, stat: 'ribs', type: 'team' }
             ],
             latestYear: null,
-            yearFilters: ["All"],
-            curYearIndex: 0,
-            sortedColumnIdx: 2
+            upperYearFilters: [],
+            lowerYearFilters: [],
+            lowerYearIndex: 0,
+            upperYearIndex: 0,
+            sortedColumnIdx: 2,
+            visibilityMap: {
+                'stats': {
+                    'info': true,
+                    'bbq': true,
+                    'sauce': true,
+                    'briquette': true,
+                    'ribs': true,
+                },
+                'types': {
+                    'info': true,
+                    'robot': true,
+                    'team': true
+                }
+            }
         }
     },
     created() {
-        this.getAvailableYears();
-        this.rankEvents();
+        this.initComponent();
+    },
+    computed: {
+        lowerYearDisplay() {
+            if (this.lowerYearIndex < this.lowerYearFilters.length) {
+                return this.lowerYearFilters[this.lowerYearIndex];
+            }
+            return ""
+        },
+        upperYearDisplay() {
+            if (this.upperYearIndex < this.upperYearFilters.length) {
+                return this.upperYearFilters[this.upperYearIndex];
+            }
+            return ""
+        },
     },
     methods: {
+        async initComponent() {
+            await this.getAvailableYears();
+            this.rankEvents();
+        },
         async getAvailableYears() {
-            this.yearFilters = ["All Years"];
+            this.upperYearFilters = [];
 
             // Get the latest event year in the database.
             const { data, error } = await supabase.from("Event").select().order("year", { ascending: false }).limit(1);
@@ -84,23 +161,32 @@ export default {
             const kFirstYear = 1992;
             if (this.latestYear) {
                 for (let y = this.latestYear; y >= kFirstYear; y--) {
-                    this.yearFilters.push(y);
+                    this.upperYearFilters.push(y);
                 }
             }
+
+            // Reverse the lower year filter to count up.
+            this.lowerYearFilters = this.upperYearFilters.slice().reverse();
         },
         async getEvents() {
-            // Get the active column.
-            let activeDbColumn = this.tableColumns[this.sortedColumnIdx].db_col;
+            // Get the active column. The active column must be visible.
+            let visibleCols = this.tableColumns.filter(col => col.visible == true);
+            let activeDbColumn = visibleCols[this.sortedColumnIdx].db_col;
 
             this.loadingEvents = true;
             let query = supabase.from("EventData")
-                .select("event_id, robot_bbq, team_bbq, Event!inner( event_id, name, year, type, type_string )")
+                .select("*, Event!inner( event_id, name, year, type, type_string )")
                 .order(activeDbColumn, { ascending: false });
 
             // Apply the year filtering.
-            let year = this.yearFilters[this.curYearIndex];
-            if (year != "All Years") {
-                query = query.eq("Event.year", year);
+            let upperYear = this.upperYearFilters[this.upperYearIndex];
+            if (upperYear) {
+                query = query.lte("Event.year", upperYear);
+            }
+
+            let lowerYear = this.lowerYearFilters[this.lowerYearIndex];
+            if (lowerYear) {
+                query = query.gte("Event.year", lowerYear);
             }
 
             const { data, error } = await query.limit(100);
@@ -110,6 +196,16 @@ export default {
                 console.log(error);
             } else {
                 for (let i = 0; i < data.length; i++) {
+
+                    let dataValid = (data[i].robot_bbq
+                        && data[i].team_bbq
+                        && data[i].robot_sauce
+                        && data[i].team_sauce
+                        && data[i].robot_briquette
+                        && data[i].team_briquette
+                        && data[i].robot_ribs
+                        && data[i].team_ribs);
+
                     let eventInfo = {
                         "name": data[i].Event.name,
                         "year": data[i].Event.year,
@@ -120,12 +216,39 @@ export default {
                                 "value": data[i].robot_bbq
                             },
                             {
-                                "name": "Team Atrribute BBQ",
+                                "name": "Team Attribute BBQ",
                                 "value": data[i].team_bbq
+                            },
+                            {
+                                "name": "Robot SAUCE",
+                                "value": data[i].robot_sauce
+                            },
+                            {
+                                "name": "Team Attribute SAUCE",
+                                "value": data[i].team_sauce
+                            },
+                            {
+                                "name": "Robot BRIQUETTE",
+                                "value": data[i].robot_briquette
+                            },
+                            {
+                                "name": "Team Attribute BRIQUETTE",
+                                "value": data[i].team_briquette
+                            },
+                            {
+                                "name": "Robot RIBS",
+                                "value": data[i].robot_ribs
+                            },
+                            {
+                                "name": "Team Attribute RIBS",
+                                "value": data[i].team_ribs
                             }
                         ]
                     }
-                    stagedList.push(eventInfo);
+
+                    if (dataValid) {
+                        stagedList.push(eventInfo);
+                    }
                 }
             }
 
@@ -137,8 +260,12 @@ export default {
         async rankEvents() {
             await this.getEvents();
         },
-        setActiveYearFilter(yearIdx) {
-            this.curYearIndex = yearIdx;
+        setLowerYearFilter(yearIdx) {
+            this.lowerYearIndex = yearIdx;
+            this.rankEvents();
+        },
+        setUpperYearFilter(yearIdx) {
+            this.upperYearIndex = yearIdx;
             this.rankEvents();
         },
         sortColumn(col_idx) {
@@ -146,6 +273,48 @@ export default {
                 this.sortedColumnIdx = col_idx;
                 this.rankEvents();
             }
+        },
+        toggleStatFilter(stat) {
+            if (Object.keys(this.visibilityMap.stats).includes(stat)) {
+                this.visibilityMap.stats[stat] = !this.visibilityMap.stats[stat];
+                this.updateColumnVisibility();
+            }
+        },
+        toggleTypeFilter(stat_type) {
+            if (Object.keys(this.visibilityMap.types).includes(stat_type)) {
+                this.visibilityMap.types[stat_type] = !this.visibilityMap.types[stat_type];
+                this.updateColumnVisibility();
+            }
+        },
+        getStatChipStatus(stat) {
+            if (Object.keys(this.visibilityMap.stats).includes(stat)) {
+                return this.visibilityMap.stats[stat];
+            }
+            return false;
+        },
+        getTypeChipStatus(stat_type) {
+            if (Object.keys(this.visibilityMap.types).includes(stat_type)) {
+                return this.visibilityMap.types[stat_type];
+            }
+            return false;
+        },
+        updateColumnVisibility() {
+            for (var i in this.tableColumns) {
+                let colType = this.tableColumns[i].type;
+                let colStat = this.tableColumns[i].stat;
+
+                if (Object.keys(this.visibilityMap.types).includes(colType) && Object.keys(this.visibilityMap.stats).includes(colStat)) {
+                    let visibility = (this.visibilityMap.types[colType]) && (this.visibilityMap.stats[colStat]);
+                    this.tableColumns[i].visible = visibility;
+                }
+            }
+
+            // Reset the sorted column index since we don't really know what got removed.
+            // TODO: make this smarter and retain the sorted column if possible.
+            this.sortedColumnIdx = 2;
+
+            // re-rank events
+            this.rankEvents();
         }
     },
 }
@@ -154,6 +323,26 @@ export default {
 <style scoped>
 .filter-container {
     display: flex;
+    flex-wrap: wrap;
+    justify-content: center;
+}
+
+.filter-options {
+    display: flex;
+    flex-direction: column;
+    width: fit-content;
+    margin-left: 20px;
+    margin-right: 20px;
+}
+
+.vertical-chip-set {
+    display: flex;
+    flex-direction: column;
+    flex-wrap: wrap;
+}
+
+.vertical-chip-set-chip {
+    margin-bottom: 5px;
 }
 
 .ranking-container {
diff --git a/src/views/EventView.vue b/src/views/EventView.vue
index 287b396..0c99bc1 100644
--- a/src/views/EventView.vue
+++ b/src/views/EventView.vue
@@ -189,6 +189,30 @@ export default {
                     {
                         "name": "Team Attribute BBQ",
                         "value": data[0].team_bbq
+                    },
+                    {
+                        "name": "Robot SAUCE",
+                        "value": data[0].robot_sauce
+                    },
+                    {
+                        "name": "Team Attribute SAUCE",
+                        "value": data[0].team_sauce
+                    },
+                    {
+                        "name": "Robot BRIQUETTE",
+                        "value": data[0].robot_briquette
+                    },
+                    {
+                        "name": "Team Attribute BRIQUETTE",
+                        "value": data[0].team_briquette
+                    },
+                    {
+                        "name": "Robot RIBS",
+                        "value": data[0].robot_ribs
+                    },
+                    {
+                        "name": "Team Attribute RIBS",
+                        "value": data[0].team_ribs
                     }
                 ]
             }
diff --git a/util/data_loader.py b/util/data_loader.py
index 4d2b657..ae3332d 100644
--- a/util/data_loader.py
+++ b/util/data_loader.py
@@ -120,5 +120,11 @@ def load_team_info(self):
         print(report)
 
     def close(self):
-        # Log out of supabase. If we don't do this, then the program will never end.
-        self.supabase_api.logout()
+        try:
+            # Log out of supabase. If we don't do this, then the program will never end.
+            self.supabase_api.logout()
+        except Exception as e:
+            # HACK: If there's an error, just print the exception and proceed.
+            # This is a quick way of allowing the script to close in the event of 
+            # underlying connections closing prior to the supabase API closing.
+            print(e)
diff --git a/util/event_processor.py b/util/event_processor.py
index 5bf291c..da4e8aa 100644
--- a/util/event_processor.py
+++ b/util/event_processor.py
@@ -35,7 +35,7 @@ def load_year_event_info(self, year: int):
             }
             self.event_queue.append(event_info)
 
-    def compute_bbq_contribution(self, start_date, event_id: str, team_number: int, banner_type: str):
+    def get_prior_banners(self, start_date, event_id: str, team_number: int, banner_type: str):
         # Only consider blue banners won by this team at earlier events to this one.
         # Some events feed into other events, and give awards on the same day (i.e. Championship divisions
         # award blue banners the same day that Einstein does). To handle these scenarios, we must check
@@ -68,12 +68,39 @@ def compute_bbq_contribution(self, start_date, event_id: str, team_number: int,
         # hint, the query will return all BlueBanners won by a team with "Event: None"
         # rather than applying the correct filter.
         banners = self.supabase_api.get_data('BlueBanner',
-                                             'event_id, type, team_number, id_string, Event!inner(event_id, start_date)',
+                                             'event_id, type, team_number, id_string, Event!inner(event_id, start_date, year)',
                                              bb_filter)
         banners_dict = banners.model_dump()
-        num_banners = 0
+        team_blue_banners = []
         if 'data' in banners_dict:
-            num_banners = len(banners_dict['data'])
+            team_blue_banners = banners_dict['data']
+
+        return team_blue_banners
+
+    def compute_bbq_contribution(self, blue_banners: dict):
+        num_banners = len(blue_banners)
+        return num_banners
+
+    def compute_sauce_contribution(self, blue_banners: dict, event_year: int):
+        # Note: Any event pre-2005 will have 0 sauce.
+        if event_year < 2005:
+            return 0
+
+        sauce_banners = [banner for banner in blue_banners if banner['Event']['year'] >= 2005]
+        num_banners = len(sauce_banners)
+
+        return num_banners
+
+    def compute_rolling_contribution(self, blue_banners: dict, event_year: int, n_seasons: int):
+        # Only consider blue banners won by this team at earlier events to this one, and only including the
+        # most recent N seasons (plus the season in progress). For example, a BRIQUETTE (N=4) from 2024 will include
+        # 2024, 2023, 2022, 2021 and 2020 banners.
+        # Some events feed into other events, and give awards on the same day (i.e. Championship divisions
+        # award blue banners the same day that Einstein does). To handle these scenarios, we must check
+        # that an event associated with a blue banner has an earlier start date than the current event.
+        min_year = event_year - n_seasons
+        rolling_banners = [banner for banner in blue_banners if banner['Event']['year'] >= min_year]
+        num_banners = len(rolling_banners)
 
         return num_banners
 
@@ -88,10 +115,22 @@ def compute_event_statistics(self, event_info: dict):
         n_teams = 0
         n_banners_robot_bbq = 0
         n_banners_team_bbq = 0
+        n_banners_robot_sauce = 0
+        n_banners_team_sauce = 0
+        n_banners_robot_briquette = 0
+        n_banners_team_briquette = 0
+        n_banners_robot_ribs = 0
+        n_banners_team_ribs = 0
 
         # Aggregated data.
         robot_bbq = 0
         team_bbq = 0
+        robot_sauce = 0
+        team_sauce = 0
+        robot_briquette = 0
+        team_briquette = 0
+        robot_ribs = 0
+        team_ribs = 0
         appearances = []
         try:
             for team in event_teams_data.json():
@@ -106,19 +145,48 @@ def compute_event_statistics(self, event_info: dict):
                 }
                 appearances.append(appearance)
 
-                # Get the blue banners won by this particular team prior to this event's start.
-                n_banners_robot_bbq += self.compute_bbq_contribution(
+                # Get the blue banners won by this particular team prior to this event's start,
+                # and use that to aggregate the various stats.
+                robot_banners = self.get_prior_banners(
                     event_info['start_date'], event_id, team_number, "Robot")
-                n_banners_team_bbq += self.compute_bbq_contribution(
+                team_banners = self.get_prior_banners(
                     event_info['start_date'], event_id, team_number, "Team")
 
-            # Compute BBQ (n_banners / n_teams)
+                # BBQ
+                n_banners_robot_bbq += self.compute_bbq_contribution(robot_banners)
+                n_banners_team_bbq += self.compute_bbq_contribution(team_banners)
+
+                # SAUCE (BBQ since 2005)
+                n_banners_robot_sauce += self.compute_sauce_contribution(
+                    robot_banners, event_info['year'])
+                n_banners_team_sauce += self.compute_sauce_contribution(
+                    team_banners, event_info['year'])
+
+                # BRIQUETTE (BBQ only using the most recent 4 years)
+                n_banners_robot_briquette += self.compute_rolling_contribution(
+                    robot_banners, event_info['year'], 4)
+                n_banners_team_briquette += self.compute_rolling_contribution(
+                    team_banners, event_info['year'], 4)
+
+                # RIBS (BBQ only using the most recent year)
+                n_banners_robot_ribs += self.compute_rolling_contribution(
+                    robot_banners, event_info['year'], 1)
+                n_banners_team_ribs += self.compute_rolling_contribution(
+                    team_banners, event_info['year'], 1)
+
+            # Compute stats (BBQ, SAUCE, BRIQUETTE, RIBS)
             if n_teams > 0:
                 robot_bbq = n_banners_robot_bbq / n_teams
                 team_bbq = n_banners_team_bbq / n_teams
-
-                # Delete all teams from the attendance list. This allows event 
-                # appearances to be completely refreshed later when the appearance 
+                robot_sauce = n_banners_robot_sauce / n_teams
+                team_sauce = n_banners_team_sauce / n_teams
+                robot_briquette = n_banners_robot_briquette / n_teams
+                team_briquette = n_banners_team_briquette / n_teams
+                robot_ribs = n_banners_robot_ribs / n_teams
+                team_ribs = n_banners_team_ribs / n_teams
+
+                # Delete all teams from the attendance list. This allows event
+                # appearances to be completely refreshed later when the appearance
                 # queue is upserted.
                 appearance_filter = [{
                     "column": "event_id",
@@ -126,7 +194,7 @@ def compute_event_statistics(self, event_info: dict):
                     "operation": "eq"
                 }]
                 self.supabase_api.delete_rows("Appearance", appearance_filter)
-                
+
                 # Update appearances for each event in order to avoid events being momentarily blank.
                 _ = self.supabase_api.upsert_batch(appearances, "Appearance")
         except Exception as e:
@@ -138,7 +206,13 @@ def compute_event_statistics(self, event_info: dict):
         event_data = {
             "event_id": event_info['event_id'],
             "robot_bbq": robot_bbq,
-            "team_bbq": team_bbq
+            "team_bbq": team_bbq,
+            "robot_sauce": robot_sauce,
+            "team_sauce": team_sauce,
+            "robot_briquette": robot_briquette,
+            "team_briquette": team_briquette,
+            "robot_ribs": robot_ribs,
+            "team_ribs": team_ribs
         }
         self.event_data_queue.append(event_data)
 
diff --git a/util/main.py b/util/main.py
index 86619d4..06d4b17 100644
--- a/util/main.py
+++ b/util/main.py
@@ -2,6 +2,7 @@
 
 import argparse
 import json
+import sys
 
 from data_loader import DataLoader
 
@@ -71,5 +72,6 @@ def load_events(event_mode: str, year: int, update_event_data: bool):
     elif args.mode == "event":
         load_events(args.event_mode, args.year, not args.info_only)
 
-    # The banner factory must be closed or else the supabase process will continue to run and hang the terminal.
+    # The data loader must be closed or else the supabase process will continue to run and hang the terminal.
+    # Note: by not setting the auto-refresh token in supabase_api.py, if close() fails the script will still exit.
     data_loader.close()
diff --git a/util/supabase_api.py b/util/supabase_api.py
index 488683c..cd85b71 100644
--- a/util/supabase_api.py
+++ b/util/supabase_api.py
@@ -1,6 +1,6 @@
 
 
-from supabase import create_client, Client
+from supabase import create_client, Client, ClientOptions
 from postgrest import SyncSelectRequestBuilder, SyncFilterRequestBuilder
 from postgrest.base_request_builder import BaseFilterRequestBuilder
 from typing import Union
@@ -8,8 +8,9 @@
 class SupabaseAPI:
 
     def __init__(self, supabase_api_info: dict):
+        # Setting auto_refresh_token = False ensures the supabase client doesn't hang the script if the program ends.
         self.supabase_client: Client = create_client(
-            supabase_url=supabase_api_info['base_url'], supabase_key=supabase_api_info['api_key'])
+            supabase_url=supabase_api_info['base_url'], supabase_key=supabase_api_info['api_key'], options=ClientOptions(auto_refresh_token=False))
 
         # Log in using the supabase award inserter credentials in order to be able to post updates to the database.
         self.supabase_user = self.supabase_client.auth.sign_in_with_password(
@@ -75,6 +76,10 @@ def _filter_process(self, request_builder: BaseFilterRequestBuilder, filter: lis
                 request_builder = request_builder.lt(f['column'], f['value'])
             elif f['operation'] == 'lte':
                 request_builder = request_builder.lte(f['column'], f['value'])
+            elif f['operation'] == 'gt':
+                request_builder = request_builder.gt(f['column'], f['value'])
+            elif f['operation'] == 'gte':
+                request_builder = request_builder.gte(f['column'], f['value'])
 
     def get_data(self, table: str, columns: str, filter: list):
         request_builder: SyncSelectRequestBuilder = self.supabase_client.table(table).select(columns)
@@ -110,3 +115,5 @@ def delete_rows(self, table: str, filter: list):
 
     def logout(self):
         res = self.supabase_client.auth.sign_out()
+        if res is not None:
+            print(res)