new_format.py

#!/usr/bin/env python3
"""
New Format Parser - Reads the new spreadsheet format.
"""

from datetime import date
from typing import Optional, List, Dict, Set, Tuple
from sheets_client import GoogleSheetsClient
from data_models import AttendanceRecord, MembershipRecord


# Google Sheets Configuration
SPREADSHEET_ID = "1GcFgxK6xaJdJoqRhfeGAHvXA2SjTCyG08Dbs7aGE8_4"
ATTENDANCE_SHEET = "ATTENDANCE"
MEMBERSHIP_SHEET = "MEMBERSHIP"


class NewFormatParser:
    """Main class for managing attendance and membership data in the new format."""
    
    def __init__(self, client: Optional[GoogleSheetsClient] = None):
        """
        Initialize the new format parser.
        
        Args:
            client: GoogleSheetsClient instance. If None, a new one will be created.
        """
        self.client = client if client is not None else GoogleSheetsClient()
        self.members_by_eid: Dict[str, MembershipRecord] = {}
        self.unique_attendance: Set[Tuple[date, str, str, str]] = set()
        
    def authenticate(self) -> None:
        """
        Authenticate with Google Sheets API using OAuth2 flow.
        Opens browser for user to login with Google account.
        """
        if not self.client.is_authenticated:
            self.client.authenticate()
        
    def get_attendance_records(self) -> List[AttendanceRecord]:
        """
        Fetch all attendance records from the spreadsheet.
        Also populates unique_attendance set with (date, eid, activity, subactivity) tuples.
        
        Returns:
            List of AttendanceRecord objects
        """
        if not self.client.is_authenticated:
            raise RuntimeError("Must authenticate before fetching records")
            
        all_values = self.client.get_worksheet_data(SPREADSHEET_ID, ATTENDANCE_SHEET)
        
        # Skip header row
        records = []
        self.unique_attendance.clear()
        
        for row in all_values[1:]:
            if row[0]:  # Skip empty rows
                try:
                    record = AttendanceRecord.from_row(row)
                    records.append(record)
                    # Add to unique attendance set as (date, eid, activity, subactivity)
                    attendance_tuple = (
                        record.timestamp.date(),
                        record.eid,
                        record.activity,
                        record.subactivity
                    )
                    self.unique_attendance.add(attendance_tuple)
                except (ValueError, IndexError) as e:
                    print(f"Warning: Skipping invalid row: {row}. Error: {e}")
                    
        return records
    
    def get_membership_records(self) -> List[MembershipRecord]:
        """
        Fetch all membership records from the spreadsheet.
        Also populates members_by_eid dictionary with EID as key.
        
        Returns:
            List of MembershipRecord objects
        """
        if not self.client.is_authenticated:
            raise RuntimeError("Must authenticate before fetching records")
            
        all_values = self.client.get_worksheet_data(SPREADSHEET_ID, MEMBERSHIP_SHEET)
        
        # Skip header row
        records = []
        self.members_by_eid.clear()
        
        for row in all_values[1:]:
            if row[0]:  # Skip empty rows
                try:
                    record = MembershipRecord.from_row(row)
                    records.append(record)
                    # Store in dictionary by EID (latest record wins if duplicates)
                    self.members_by_eid[record.eid] = record
                except (ValueError, IndexError) as e:
                    print(f"Warning: Skipping invalid row: {row}. Error: {e}")
                    
        return records
    
    def get_member_by_eid(self, eid: str) -> Optional[MembershipRecord]:
        """
        Get a member's record by their EID from the cached dictionary.
        
        Args:
            eid: The member's EID
            
        Returns:
            MembershipRecord if found, None otherwise
        """
        # Use cached dictionary if available
        if self.members_by_eid:
            return self.members_by_eid.get(eid)
        
        # Otherwise fetch and cache
        self.get_membership_records()
        return self.members_by_eid.get(eid)
    
    def get_attendance_by_eid(self, eid: str) -> List[AttendanceRecord]:
        """
        Get all attendance records for a specific EID.
        
        Args:
            eid: The member's EID
            
        Returns:
            List of AttendanceRecord objects for the given EID
        """
        all_attendance = self.get_attendance_records()
        return [record for record in all_attendance if record.eid == eid]
    
    def get_attendance_by_activity(self, activity: str) -> List[AttendanceRecord]:
        """
        Get all attendance records for a specific activity.
        
        Args:
            activity: The activity name
            
        Returns:
            List of AttendanceRecord objects for the given activity
        """
        all_attendance = self.get_attendance_records()
        return [record for record in all_attendance if record.activity == activity]


def main() -> None:
    """Main function to demonstrate usage."""
    # Initialize the parser (uses credentials.json by default)
    parser = NewFormatParser()
    
    try:
        # Authenticate
        print("Authenticating with Google Sheets...")
        parser.authenticate()
        print("✓ Authentication successful\n")
        
        # Fetch and display attendance records
        print("Fetching attendance records...")
        attendance_records = parser.get_attendance_records()
        print(f"✓ Found {len(attendance_records)} attendance records")
        print("\nFirst 5 attendance records:")
        for record in attendance_records[:5]:
            print(f"  {record.eid} - {record.activity} - {record.timestamp}")
        
        # Fetch and display membership records
        print("\nFetching membership records...")
        membership_records = parser.get_membership_records()
        print(f"✓ Found {len(membership_records)} membership records")
        print("\nFirst 5 membership records:")
        for record in membership_records[:5]:
            print(f"  {record.eid} - {record.firstname} {record.lastname} - {record.committees}")
        
        # Example: Get specific member's attendance
        print("\n--- Example: Get attendance for km54774 ---")
        member_attendance = parser.get_attendance_by_eid("km54774")
        print(f"Found {len(member_attendance)} attendance records for km54774")
        for record in member_attendance:
            print(f"  {record.activity} - {record.timestamp}")
            
    except Exception as e:
        print(f"Error: {e}")


if __name__ == "__main__":
    main()