Update app.py

app.py

@@ -1,13 +1,14 @@
 """
 Baseball statistics application with txtai and Streamlit.
 
-Install txtai and streamlit to run:
+Install txtai and streamlit (>= 1.23) to run:
   pip install txtai streamlit
 """
 
 import datetime
 import os
 
+import altair as alt
 import numpy as np
 import pandas as pd
 import streamlit as st
@@ -57,15 +58,12 @@ class Stats:
 
         raise NotImplementedError
 
-    def sort(self, rows):
+    def metric(self):
         """
-        Sorts rows stored as a DataFrame.
-
-        Args:
-            rows: input DataFrame
+        Primary metric column.
 
         Returns:
-            sorted DataFrame
+            metric column name
         """
 
         raise NotImplementedError
@@ -116,30 +114,41 @@ class Stats:
         vectors = {f'{row["yearID"]}{row["playerID"]}': self.transform(row) for _, row in self.stats.iterrows()}
         data = {f'{row["yearID"]}{row["playerID"]}': dict(row) for _, row in self.stats.iterrows()}
 
-        embeddings = Embeddings({
-            "transform": self.transform,
-        })
+        embeddings = Embeddings(
+            {
+                "transform": self.transform,
+            }
+        )
 
         embeddings.index((uid, vectors[uid], None) for uid in vectors)
 
         return vectors, data, embeddings
 
-    def years(self, player):
+    def metrics(self, player):
         """
-        Looks up the years active for a player along with the player's best statistical year.
+        Looks up a player's active years, best statistical year and key metrics.
 
         Args:
             player: player name
 
         Returns:
-            start, end, best
+            active, best, metrics
         """
 
         if player in self.names:
-            df = self.sort(self.stats[self.stats["playerID"] == self.names[player]])
-            return int(df["yearID"].min()), int(df["yearID"].max()), int(df["yearID"].iloc[0])
+            # Get player stats
+            stats = self.stats[self.stats["playerID"] == self.names[player]]
+
+            # Build key metrics
+            metrics = stats[["yearID", self.metric()]]
+
+            # Get best year, sort by primary metric
+            best = int(stats.sort_values(by=self.metric(), ascending=False)["yearID"].iloc[0])
 
-        return 1871, datetime.datetime.today().year, 1950
+            # Get years active, best year, along with metric trends
+            return metrics["yearID"].tolist(), best, metrics
+
+        return range(1871, datetime.datetime.today().year), 1950, None
 
     def search(self, player=None, year=None, row=None, limit=10):
         """
@@ -196,10 +205,42 @@ class Stats:
 
 
 class Batting(Stats):
+    """
+    Batting stats.
+    """
+
     def loadcolumns(self):
         return [
-            "birthMonth", "age", "weight", "height", "yearID", "G", "AB", "R", "H", "1B", "2B", "3B", "HR", "RBI", "SB", "CS",
-            "BB", "SO", "IBB", "HBP", "SH", "SF", "GIDP", "POS", "AVG", "OBP", "TB", "SLG", "OPS", "OPS+"
+            "birthMonth",
+            "yearID",
+            "age",
+            "height",
+            "weight",
+            "G",
+            "AB",
+            "R",
+            "H",
+            "1B",
+            "2B",
+            "3B",
+            "HR",
+            "RBI",
+            "SB",
+            "CS",
+            "BB",
+            "SO",
+            "IBB",
+            "HBP",
+            "SH",
+            "SF",
+            "GIDP",
+            "POS",
+            "AVG",
+            "OBP",
+            "TB",
+            "SLG",
+            "OPS",
+            "OPS+",
         ]
 
     def load(self):
@@ -230,8 +271,8 @@ class Batting(Stats):
 
         return batting
 
-    def sort(self, rows):
-        return rows.sort_values(by="OPS+", ascending=False)
+    def metric(self):
+        return "OPS+"
 
     def vector(self, row):
         row["TB"] = row["1B"] + 2 * row["2B"] + 3 * row["3B"] + 4 * row["HR"]
@@ -255,7 +296,7 @@ class Batting(Stats):
         """
 
         positions = {}
-        for x, row in fielding.iterrows():
+        for _, row in fielding.iterrows():
             uid = f'{row["yearID"]}{row["playerID"]}'
             position = row["POS"] if row["POS"] else 0
             if position == "P":
@@ -294,12 +335,46 @@ class Batting(Stats):
         uid = f'{row["yearID"]}{row["playerID"]}'
         return positions[uid][0] if uid in positions else 0
 
+
 class Pitching(Stats):
+    """
+    Pitching stats.
+    """
+
     def loadcolumns(self):
         return [
-            "birthMonth", "age", "weight", "height", "yearID", "W", "L", "G", "GS", "CG", "SHO", "SV", "IPouts",
-            "H", "ER", "HR", "BB", "SO", "BAOpp", "ERA", "IBB", "WP", "HBP", "BK", "BFP", "GF", "R", "SH", "SF",
-            "GIDP", "WHIP", "WADJ"
+            "birthMonth",
+            "yearID",
+            "age",
+            "height",
+            "weight",
+            "W",
+            "L",
+            "G",
+            "GS",
+            "CG",
+            "SHO",
+            "SV",
+            "IPouts",
+            "H",
+            "ER",
+            "HR",
+            "BB",
+            "SO",
+            "BAOpp",
+            "ERA",
+            "IBB",
+            "WP",
+            "HBP",
+            "BK",
+            "BFP",
+            "GF",
+            "R",
+            "SH",
+            "SF",
+            "GIDP",
+            "WHIP",
+            "WADJ",
         ]
 
     def load(self):
@@ -316,16 +391,16 @@ class Pitching(Stats):
         # Calculated columns
         pitching["age"] = pitching["yearID"] - pitching["birthYear"]
         pitching["WHIP"] = (pitching["BB"] + pitching["H"]) / (pitching["IPouts"] / 3)
-        pitching["WADJ"] =(pitching["W"] + pitching["SV"]) / (pitching["ERA"] + pitching["WHIP"])
+        pitching["WADJ"] = (pitching["W"] + pitching["SV"]) / (pitching["ERA"] + pitching["WHIP"])
 
         return pitching
 
-    def sort(self, rows):
-        return rows.sort_values(by="WADJ", ascending=False)
+    def metric(self):
+        return "WADJ"
 
     def vector(self, row):
         row["WHIP"] = (row["BB"] + row["H"]) / (row["IPouts"] / 3) if row["IPouts"] else None
-        row["WADJ"] =(row["W"] + row["SV"]) / (row["ERA"] + row["WHIP"]) if row["ERA"] and row["WHIP"] else None
+        row["WADJ"] = (row["W"] + row["SV"]) / (row["ERA"] + row["WHIP"]) if row["ERA"] and row["WHIP"] else None
 
         return self.transform(row)
 
@@ -352,13 +427,15 @@ class Application:
         """
 
         st.title("⚾ Baseball Statistics")
-        st.markdown("""
+        st.markdown(
+            """
             This application finds the best matching historical players using vector search with [txtai](https://github.com/neuml/txtai).
             Raw data is from the [Baseball Databank](https://github.com/chadwickbureau/baseballdatabank) GitHub project. 
-        """)
+        """
+        )
 
         self.player()
-        
+
     def player(self):
         """
         Player tab.
@@ -373,19 +450,59 @@ class Application:
         names = sorted(stats.names)
         player = st.selectbox("Player", names, names.index(default))
 
+        # Player metrics
+        active, best, metrics = stats.metrics(player)
+
         # Player year
-        start, end, best = stats.years(player)
-        year = st.slider("Year", start, end, best) if start != end else start
+        year = int(st.select_slider("Year", active, best) if len(active) > 1 else active[0])
+
+        # Display metrics chart
+        if len(active) > 1:
+            self.chart(category, metrics)
 
         # Run search
         results = stats.search(player, year)
 
         # Display results
-        self.display(results, ["nameFirst", "nameLast", "teamID"] + stats.columns[1:] + ["link"])
+        self.table(results, ["nameFirst", "nameLast", "teamID"] + stats.columns[1:] + ["link"])
+
+    def chart(self, category, metrics):
+        """
+        Displays a metric chart.
+
+        Args:
+            category: Batting or Pitching
+            metrics: player metrics to plot
+        """
+
+        # Key metric
+        metric = self.batting.metric() if category == "Batting" else self.pitching.metric()
+
+        # Cast year to string
+        metrics["yearID"] = metrics["yearID"].astype(str)
+
+        # Metric over years
+        chart = (
+            alt.Chart(metrics)
+            .mark_line(interpolate="monotone", point=True, strokeWidth=2.5, opacity=0.75)
+            .encode(
+                x=alt.X("yearID", title="").scale(padding=0),
+                y=alt.Y(metric).scale(zero=False, padding=0),
+            )
+        )
+
+        # Create metric median rule line
+        rule = alt.Chart(metrics).mark_rule(color="gray", strokeDash=[3, 5], opacity=0.5).encode(y=f"median({metric})")
+
+        # Layered chart configuration
+        chart = (chart + rule).encode(y=alt.Y(title=metric)).properties(height=200).configure_axis(grid=False)
+
+        # Draw chart
+        st.altair_chart(chart + rule, theme="streamlit", use_container_width=True)
 
-    def display(self, results, columns):
+    def table(self, results, columns):
         """
-        Displays a list of results.
+        Displays a list of results as a table.
 
         Args:
             results: list of results