Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,14 +1,13 @@
 import streamlit as st
 import requests
-import pandas as pd
+import json
 from google.oauth2.service_account import Credentials
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
-from io import StringIO
-import json
+import pandas as pd
 
 # Streamlit app title
-st.title("Rugby Premier League All Data to CSV and Google Sheets")
+st.title("Rugby Premier League Raw JSON to Google Sheets and CSV")
 
 # Input field for match ID
 match_id = st.text_input("Enter Match ID (e.g., 69)", value="69")
@@ -71,53 +70,37 @@ def get_sheets_service():
         st.error(f"Error initializing Google Sheets client: {e}")
         return None
 
-# Function to write DataFrame to Google Sheets
-def write_to_google_sheets(df, sheet_id, sheet_name):
+# Function to write JSON to Google Sheets
+def write_json_to_google_sheets(json_data, sheet_id, sheet_name):
     service = get_sheets_service()
     if service is None:
         return False
 
     try:
-        # Convert DataFrame to list of lists for Google Sheets
-        values = [df.columns.tolist()] + df.values.tolist()
+        # Convert JSON to a string
+        json_str = json.dumps(json_data, indent=2)
+        # Prepare data as a single cell value
+        values = [[json_str]]
         
-        # Clear existing data in the sheet (expanded range to handle many columns)
+        # Clear existing data in the sheet
         service.spreadsheets().values().clear(
             spreadsheetId=sheet_id,
-            range=f"{sheet_name}!A1:ZZ",
+            range=f"{sheet_name}!A1:Z",
         ).execute()
 
-        # Write new data
+        # Write JSON string to A1
         service.spreadsheets().values().update(
             spreadsheetId=sheet_id,
             range=f"{sheet_name}!A1",
             valueInputOption="RAW",
             body={"values": values}
         ).execute()
-        st.success(f"Data successfully written to Google Sheet '{sheet_name}'")
+        st.success(f"Raw JSON successfully written to Google Sheet '{sheet_name}' in cell A1")
         return True
     except HttpError as e:
         st.error(f"Error writing to Google Sheet: {e}")
         return False
 
-# Function to flatten nested dictionaries
-def flatten_dict(d, parent_key='', sep='_'):
-    items = []
-    for k, v in d.items():
-        new_key = f"{parent_key}{sep}{k}" if parent_key else k
-        if isinstance(v, dict):
-            items.extend(flatten_dict(v, new_key, sep).items())
-        elif isinstance(v, list):
-            # Handle lists by indexing them
-            for i, item in enumerate(v):
-                if isinstance(item, dict):
-                    items.extend(flatten_dict(item, f"{new_key}_{i}", sep).items())
-                else:
-                    items.append((f"{new_key}_{i}", item if item is not None else ''))
-        else:
-            items.append((new_key, v if v is not None else ''))
-    return dict(items)
-
 # Validate match ID
 if not match_id.isdigit():
     st.error("Please enter a valid numeric Match ID.")
@@ -149,107 +132,8 @@ else:
             st.error(f"Error fetching data for Match ID {match_id}: {e}")
             return None
 
-    # Function to extract and flatten all data
-    def extract_all_data(data, match_id):
-        try:
-            records = []
-
-            # Flatten match_detail
-            match_detail = data.get('match_detail', {})
-            flat_match_detail = flatten_dict(match_detail, 'match_detail')
-
-            # Handle teams
-            teams = data.get('teams', None)
-            with st.expander("Debug: Teams Field Structure"):
-                if teams is None:
-                    st.write("`teams` field is None or missing.")
-                else:
-                    st.write(f"`teams` type: {type(teams)}")
-                    st.write(f"`teams` content: {teams}")
-
-            if teams is None:
-                st.error("No 'teams' field found in the JSON response.")
-                return pd.DataFrame()
-
-            # Normalize teams to a list of dictionaries
-            team_list = []
-            if isinstance(teams, list):
-                for team_entry in teams:
-                    if isinstance(team_entry, list) and len(team_entry) == 1 and isinstance(team_entry[0], dict):
-                        team_list.append(team_entry[0])
-                    elif isinstance(team_entry, dict):
-                        team_list.append(team_entry)
-                    else:
-                        st.warning(f"Skipping invalid team entry (type: {type(team_entry)}): {team_entry}")
-            elif isinstance(teams, dict):
-                team_list = list(teams.values())
-            else:
-                st.error(f"Unsupported 'teams' type: {type(teams)}")
-                return pd.DataFrame()
-
-            if not team_list:
-                st.error("No valid teams found in the JSON response.")
-                return pd.DataFrame()
-
-            # Process teams and squad
-            for team in team_list:
-                if not isinstance(team, dict):
-                    st.warning(f"Skipping invalid team entry (type: {type(team)}): {team}")
-                    continue
-
-                team_data = flatten_dict({k: v for k, v in team.items() if k != 'squad'}, 'team')
-                squad = team.get('squad', []) or team.get('players', [])
-                if not isinstance(squad, list):
-                    st.warning(f"Invalid 'squad' type for team {team.get('name', 'Unknown')}: {type(squad)}")
-                    continue
-
-                for player in squad:
-                    if not isinstance(player, dict):
-                        st.warning(f"Skipping invalid player entry (type: {type(player)}): {player}")
-                        continue
-                    flat_player = flatten_dict(player, 'player')
-                    record = {**flat_match_detail, **team_data, **flat_player}
-                    records.append(record)
-
-            # Handle events
-            events = data.get('events', [])
-            if not isinstance(events, list):
-                st.warning(f"Invalid 'events' type: {type(events)}")
-                events = []
-
-            for event in events:
-                if not isinstance(event, dict):
-                    st.warning(f"Skipping invalid event entry (type: {type(event)}): {event}")
-                    continue
-                flat_event = flatten_dict(event, 'event')
-                record = {**flat_match_detail, **flat_event}
-                records.append(record)
-
-            if not records:
-                st.warning("No data found in the JSON response.")
-                return pd.DataFrame()
-
-            # Create DataFrame
-            df = pd.DataFrame(records)
-            # Convert numeric and boolean columns where possible
-            for col in df.columns:
-                # Try converting to numeric
-                df[col] = pd.to_numeric(df[col], errors='ignore')
-                # Convert "1"/"0" to True/False for boolean fields
-                if df[col].dtype == 'object' and any(x in col for x in [
-                    'is_onbench', 'is_substitute', 'is_substituted', 'isPlaying', 'starter', 'captain', 
-                    'is_Injured', 'is_home_team', 'yellow_Card', 'red_Card', 'isSubUp'
-                ]):
-                    df[col] = df[col].apply(lambda x: True if x == '1' or x == 1 else False if x == '0' or x == 0 else x)
-            # Replace NaN with empty string for Google Sheets compatibility
-            df = df.fillna('')
-            return df
-        except Exception as e:
-            st.error(f"Error processing data: {e}")
-            return pd.DataFrame()
-
     # Fetch and process data when button is clicked
-    if st.button("Fetch and Process All Data"):
+    if st.button("Fetch and Upload JSON"):
         data = fetch_json_data(url, match_id)
         
         if data:
@@ -257,31 +141,22 @@ else:
             with st.expander("View Raw JSON"):
                 st.json(data)
             
-            # Extract and display all data
-            df = extract_all_data(data, match_id)
+            # Upload JSON to Google Sheets
+            if st.button("Upload Raw JSON to Google Sheets"):
+                if write_json_to_google_sheets(data, SHEET_ID, SHEET_NAME):
+                    st.write(f"View the sheet [here](https://docs.google.com/spreadsheets/d/{SHEET_ID})")
+                else:
+                    st.error("Failed to upload JSON to Google Sheets.")
             
-            if not df.empty:
-                st.write(f"### All Data for Match ID {match_id}")
-                st.write(f"**Number of records**: {len(df)}")
-                st.write(f"**Columns**: {', '.join(df.columns)}")
-                st.dataframe(df, use_container_width=True)
-                
-                # Provide CSV download
-                csv = df.to_csv(index=False)
-                st.download_button(
-                    label="Download all data as CSV",
-                    data=csv,
-                    file_name=f"rugby_match_{match_id}_all_data.csv",
-                    mime="text/csv"
-                )
-                
-                # Upload to Google Sheets
-                if st.button("Upload to Google Sheets"):
-                    if write_to_google_sheets(df, SHEET_ID, SHEET_NAME):
-                        st.write(f"View the sheet [here](https://docs.google.com/spreadsheets/d/{SHEET_ID})")
-                    else:
-                        st.error("Failed to upload data to Google Sheets.")
-            else:
-                st.warning(f"No data available for Match ID {match_id}.")
+            # Provide CSV download with JSON string
+            json_str = json.dumps(data, indent=2)
+            df_csv = pd.DataFrame([["json_data"], [json_str]], columns=["key", "value"])
+            csv = df_csv.to_csv(index=False)
+            st.download_button(
+                label="Download JSON as CSV",
+                data=csv,
+                file_name=f"rugby_match_{match_id}_raw.json.csv",
+                mime="text/csv"
+            )
         else:
             st.warning(f"Failed to fetch data for Match ID {match_id}.")