fix(logging): replace f-string logging with lazy %s formatting

pages/2_play_game.py

@@ -178,17 +178,17 @@ if teams_good and not st.session_state.away_team_df.empty:
             index=["Home Team", "Away Team"],
         )
 
-        logger.info(f"Prediction: {probability:.4f}")
+        logger.info("Prediction: %.4f", probability)
 
     except ModelLoadError as e:
         st.error("Could not load prediction model. Please contact support.")
-        logger.error(f"Model load error: {e}")
+        logger.error("Model load error: %s", e)
         teams_good = False
         winner_label = ""
         box_score = pd.DataFrame()
     except ValueError as e:
         st.error("Error processing team stats. Please try again.")
-        logger.error(f"Stats processing error: {e}")
+        logger.error("Stats processing error: %s", e)
         teams_good = False
         winner_label = ""
         box_score = pd.DataFrame()

scripts/compile_model.py

@@ -172,7 +172,7 @@ def train_model(
         "init": INITIALIZERS,
     }
 
-    logger.info(f"Starting randomized search with {n_iterations} iterations")
+    logger.info("Starting randomized search with %d iterations", n_iterations)
 
     random_search = RandomizedSearchCV(
         estimator=model,
@@ -195,17 +195,17 @@ def main() -> None:
     logger.info("Loading data files")
 
     if not ROSTER_FILE.exists():
-        logger.error(f"Roster file not found: {ROSTER_FILE}")
+        logger.error("Roster file not found: %s", ROSTER_FILE)
         raise FileNotFoundError(f"Missing {ROSTER_FILE}")
 
     if not SCHEDULE_FILE.exists():
-        logger.error(f"Schedule file not found: {SCHEDULE_FILE}")
+        logger.error("Schedule file not found: %s", SCHEDULE_FILE)
         raise FileNotFoundError(f"Missing {SCHEDULE_FILE}")
 
     roster = pd.read_csv(ROSTER_FILE, delimiter=",")
     schedule = pd.read_csv(SCHEDULE_FILE, delimiter=",")
 
-    logger.info(f"Loaded {len(roster)} players and {len(schedule)} games")
+    logger.info("Loaded %d players and %d games", len(roster), len(schedule))
 
     # Create target variable: 0 = home wins, 1 = away wins
     schedule["winner"] = schedule.apply(
@@ -217,14 +217,14 @@ def main() -> None:
     X = np.array(create_stats(roster, schedule))
     y = np.array(schedule["winner"])
 
-    logger.info(f"Feature shape: {X.shape}, Target shape: {y.shape}")
+    logger.info("Feature shape: %s, Target shape: %s", X.shape, y.shape)
 
     # Split data
     X_train, X_test, y_train, y_test = train_test_split(
         X, y, test_size=0.2, random_state=42
     )
 
-    logger.info(f"Train size: {len(X_train)}, Test size: {len(X_test)}")
+    logger.info("Train size: %d, Test size: %d", len(X_train), len(X_test))
 
     # Train model
     best_model, best_params, test_accuracy = train_model(
@@ -232,11 +232,11 @@ def main() -> None:
     )
 
     # Save model
-    logger.info(f"Saving model to {OUTPUT_MODEL}")
+    logger.info("Saving model to %s", OUTPUT_MODEL)
     best_model.save(OUTPUT_MODEL)
 
-    logger.info(f"Best parameters: {best_params}")
-    logger.info(f"Test accuracy: {test_accuracy:.4f}")
+    logger.info("Best parameters: %s", best_params)
+    logger.info("Test accuracy: %.4f", test_accuracy)
 
 
 if __name__ == "__main__":

src/database/queries.py

@@ -119,11 +119,11 @@ def get_away_team_by_stats(
 
             results = df.loc[list(selected_indices)]
             if len(results) == 5:
-                logger.info(f"Got away team on attempt {attempt + 1}")
+                logger.info("Got away team on attempt %d", attempt + 1)
                 return results
 
         except ValueError as e:
-            logger.debug(f"Attempt {attempt + 1} failed: {e}")
+            logger.debug("Attempt %d failed: %s", attempt + 1, e)
             continue
 
     raise QueryExecutionError(

src/ml/model.py

@@ -32,16 +32,16 @@ def get_winner_model(model_path: str | Path = DEFAULT_MODEL_PATH) -> Model:
     """
     path = Path(model_path)
     if not path.exists():
-        logger.error(f"Model file not found: {path}")
+        logger.error("Model file not found: %s", path)
         raise ModelLoadError(f"Model file not found: {path}")
 
     try:
-        logger.info(f"Loading model from {path}")
+        logger.info("Loading model from %s", path)
         model = load_model(str(path))
         logger.info("Model loaded successfully")
         return model
     except Exception as e:
-        logger.error(f"Failed to load model: {e}")
+        logger.error("Failed to load model: %s", e)
         raise ModelLoadError(f"Failed to load model: {e}") from e
 
 
@@ -71,7 +71,7 @@ def predict_winner(combined_stats: np.ndarray) -> tuple[float, int]:
     probability = float(sigmoid_output[0][0])
     prediction = int(np.round(probability))
 
-    logger.info(f"Prediction: probability={probability:.4f}, winner={prediction}")
+    logger.info("Prediction: probability=%.4f, winner=%d", probability, prediction)
     return probability, prediction
 
 

src/state/session.py

@@ -32,7 +32,7 @@ def init_session_state() -> None:
     for key, default_value in defaults.items():
         if key not in st.session_state:
             st.session_state[key] = default_value
-            logger.debug(f"Initialized session state: {key}")
+            logger.debug("Initialized session state: %s", key)
 
 
 def get_away_stats() -> list[int]: