Upload 5 files

src/build_campaign_events.py

@@ -0,0 +1,92 @@
+import pandas as pd
+import glob
+import os
+from tqdm import tqdm
+import sys
+
+# Get the absolute path to the project root (two directories up from data_prep)
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+if project_root not in sys.path:
+    sys.path.append(project_root)
+import config
+
+def load_legislator_map():
+    if os.path.exists(config.LEGISLATORS_CROSSWALK_PATH):
+        # Added low_memory=False to suppress DtypeWarnings
+        df = pd.read_csv(config.LEGISLATORS_CROSSWALK_PATH, low_memory=False)
+        if 'id_opensecrets' in df.columns and 'id_bioguide' in df.columns:
+            # Drop duplicates to prevent InvalidIndexError during mapping
+            mapping_df = df[['id_opensecrets', 'id_bioguide']].dropna().drop_duplicates(subset=['id_opensecrets'])
+            return mapping_df.set_index('id_opensecrets')['id_bioguide'].to_dict()
+    print(f"WARNING: Legislator crosswalk not found at {config.LEGISLATORS_CROSSWALK_PATH}.")
+    return {}
+
+def build_campaign_events():
+    print("Building Campaign Finance Event Stream (Using Filing Dates)...")
+    
+    cid_to_bioguide = load_legislator_map()
+    all_events = []
+
+    # --- Step 1: Corporate PACs ---
+    pac_files = glob.glob(str(config.CAMPAIGN_FINANCE_DIR / config.CAMPAIGN_PACS_PATTERN))
+    
+    print(f"Found {len(pac_files)} PAC files.")
+    for f in tqdm(pac_files, desc="Processing PAC Files"):
+        df = pd.read_csv(f, on_bad_lines='skip', low_memory=False)
+        
+        if 'estimated_filing_date' not in df.columns:
+            continue
+
+        df = df.dropna(subset=['CID', 'RealCode', 'estimated_filing_date'])
+        
+        # Safely map to BioGuide IDs using the deduplicated dictionary
+        df['bioguide_id'] = df['CID'].map(cid_to_bioguide)
+        df = df.dropna(subset=['bioguide_id'])
+        
+        df = df[['estimated_filing_date', 'RealCode', 'bioguide_id', 'Amount']].copy()
+        all_events.append(df)
+
+    # --- Step 2: 527 Expenditures ---
+    if os.path.exists(config.DATA_527_EXPENDITURES_PATH):
+        print("\nProcessing 527 Expenditures...")
+        exp_df = pd.read_csv(config.DATA_527_EXPENDITURES_PATH, on_bad_lines='skip', low_memory=False)
+        cmtes_df = pd.read_csv(config.DATA_527_COMMITTEES_PATH, on_bad_lines='skip', low_memory=False)
+        
+        if 'estimated_filing_date' in exp_df.columns:
+            ein_to_industry = cmtes_df.set_index('EIN')['PrimCode'].to_dict()
+            
+            exp_df['bioguide_id'] = exp_df['RecipID'].map(cid_to_bioguide)
+            exp_df['RealCode'] = exp_df['EIN'].map(ein_to_industry)
+            
+            exp_df = exp_df.dropna(subset=['bioguide_id', 'RealCode', 'estimated_filing_date'])
+            exp_df = exp_df[['estimated_filing_date', 'RealCode', 'bioguide_id', 'Amount']].copy()
+            all_events.append(exp_df)
+        else:
+            print("Skipping 527 Expenditures: 'estimated_filing_date' missing.")
+
+    # --- Step 3: Aggregation ---
+    if all_events:
+        print("\nConcatenating and Aggregating Events...")
+        full_df = pd.concat(all_events, ignore_index=True)
+        
+        # Parse dates
+        tqdm.pandas(desc="Parsing Dates")
+        full_df['estimated_filing_date'] = pd.to_datetime(full_df['estimated_filing_date'], errors='coerce')
+        full_df = full_df.dropna(subset=['estimated_filing_date'])
+        
+        # Aggregate to Weekly "Pulses"
+        full_df = full_df.set_index('estimated_filing_date')
+        
+        # Group and sum
+        agg_df = full_df.groupby([pd.Grouper(freq='W'), 'RealCode', 'bioguide_id'])['Amount'].sum().reset_index()
+        
+        agg_df.rename(columns={'estimated_filing_date': 'date', 'RealCode': 'industry_code', 'Amount': 'weight'}, inplace=True)
+        agg_df['event_type'] = 'DONATION'
+        
+        agg_df.to_csv(config.CAMPAIGN_FINANCE_EVENTS_PATH, index=False)
+        print(f"\nSUCCESS: Saved {len(agg_df)} Campaign Events to {config.CAMPAIGN_FINANCE_EVENTS_PATH}")
+    else:
+        print("\nNo Campaign Events found.")
+
+if __name__ == "__main__":
+    build_campaign_events()

src/build_geographical_edges.py

@@ -0,0 +1,231 @@
+import pandas as pd
+import numpy as np
+import os
+import re
+import gc
+from datetime import datetime
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from tqdm import tqdm
+
+# --- CONFIGURATION ---
+RAW_DATA_DIR = "data/raw"
+CBP_DIR = os.path.join(RAW_DATA_DIR, "district_industries")
+NAICS_DIR = os.path.join(RAW_DATA_DIR, "industry_codes_NAICS")
+OUTPUT_FILE = "data/processed/events_geographical_industry.csv"
+MAX_WORKERS = os.cpu_count() - 1 or 1
+
+STATE_ABBREV = {
+    'Alabama': 'AL', 'Alaska': 'AK', 'Arizona': 'AZ', 'Arkansas': 'AR', 'California': 'CA',
+    'Colorado': 'CO', 'Connecticut': 'CT', 'Delaware': 'DE', 'Florida': 'FL', 'Georgia': 'GA',
+    'Hawaii': 'HI', 'Idaho': 'ID', 'Illinois': 'IL', 'Indiana': 'IN', 'Iowa': 'IA',
+    'Kansas': 'KS', 'Kentucky': 'KY', 'Louisiana': 'LA', 'Maine': 'ME', 'Maryland': 'MD',
+    'Massachusetts': 'MA', 'Michigan': 'MI', 'Minnesota': 'MN', 'Mississippi': 'MS',
+    'Missouri': 'MO', 'Montana': 'MT', 'Nebraska': 'NE', 'Nevada': 'NV', 'New Hampshire': 'NH',
+    'New Jersey': 'NJ', 'New Mexico': 'NM', 'New York': 'NY', 'North Carolina': 'NC',
+    'North Dakota': 'ND', 'Ohio': 'OH', 'Oklahoma': 'OK', 'Oregon': 'OR', 'Pennsylvania': 'PA',
+    'Rhode Island': 'RI', 'South Carolina': 'SC', 'South Dakota': 'SD', 'Tennessee': 'TN',
+    'Texas': 'TX', 'Utah': 'UT', 'Vermont': 'VT', 'Virginia': 'VA', 'Washington': 'WA',
+    'West Virginia': 'WV', 'Wisconsin': 'WI', 'Wyoming': 'WY', 'District of Columbia': 'DC',
+    'Puerto Rico': 'PR'
+}
+
+def load_crosswalks():
+    print("[INFO] Loading NAICS-to-SIC Crosswalks...")
+    cw_2012 = pd.read_csv(os.path.join(NAICS_DIR, "2012-NAICS-to-SIC-Crosswalk.csv"), dtype=str)
+    cw_2017 = pd.read_csv(os.path.join(NAICS_DIR, "2017-NAICS-to-SIC-Crosswalk.csv"), dtype=str)
+    
+    dict_2012 = cw_2012.groupby('NAICS')['SIC'].apply(list).to_dict()
+    dict_2017 = cw_2017.groupby('NAICS')['SIC'].apply(list).to_dict()
+    return dict_2012, dict_2017
+
+def load_release_dates():
+    print("[INFO] Loading Survey Release Dates...")
+    release_df = pd.read_csv(os.path.join(CBP_DIR, "survey_release_dates.csv"))
+    release_df['date'] = pd.to_datetime(release_df['date'], format='mixed')
+    return dict(zip(release_df['survey_reference_year'], release_df['date']))
+
+def load_legislators():
+    print("[INFO] Loading Legislator Metadata...")
+    terms_df = pd.read_csv(os.path.join(RAW_DATA_DIR, "congress_terms_all_github.csv"), low_memory=False)
+    terms_df['start'] = pd.to_datetime(terms_df['start'])
+    terms_df['end'] = pd.to_datetime(terms_df['end'])
+    terms_df['district'] = terms_df['district'].replace('At Large', 0)
+    terms_df['district'] = pd.to_numeric(terms_df['district'], errors='coerce')
+    return terms_df
+
+def parse_geography(name_str):
+    if pd.isna(name_str):
+        return None, None
+    match = re.search(r'(?:Congressional District (\d+)|District \(At Large\)).*?,\s*(.*)', str(name_str), re.IGNORECASE)
+    if match:
+        dist_str = match.group(1)
+        district = int(dist_str) if dist_str else 0
+        state_name = match.group(2).strip()
+        state_abbr = STATE_ABBREV.get(state_name, None)
+        return state_abbr, district
+    return None, None
+
+def get_active_legislator(terms_df, state, district, release_date):
+    if state is None or pd.isna(district):
+        return None
+    active = terms_df[
+        (terms_df['state'] == state) & 
+        (terms_df['district'] == district) & 
+        (terms_df['start'] <= release_date) & 
+        (terms_df['end'] >= release_date) &
+        (terms_df['type'] == 'rep')
+    ]
+    if not active.empty:
+        return active.iloc[0]['id_bioguide']
+    return None
+
+def process_chunk(chunk, year, release_date, crosswalk, terms_df):
+    edges = []
+    cols = chunk.columns
+    
+    # Safely find columns dynamically to handle schema evolution
+    col_name = next((c for c in cols if 'NAME' in c), None)
+    col_naics = next((c for c in cols if 'NAICS' in c and 'LABEL' not in c), None)
+    col_estab = next((c for c in cols if 'ESTAB' in c), None)
+    col_emp = next((c for c in cols if 'EMP' in c and 'EMPSZES' not in c), None)
+    col_payann = next((c for c in cols if 'PAYANN' in c), None)
+    
+    if not all([col_name, col_naics, col_estab, col_emp, col_payann]):
+        return pd.DataFrame()
+
+    # --- THE FIX: FILTER OUT GRANULAR ROWS ---
+    naics_raw = chunk[col_naics].astype(str).str.strip()
+    
+    # Match ONLY top-level 2-digit sectors (e.g., '11', '11----') or hyphenated groups ('31-33')
+    is_top_level = naics_raw.str.match(r'^(\d{2}-*|\d{2}-\d{2}-*)$')
+    is_not_total = ~naics_raw.str.startswith('00') # Exclude the "All Sectors" total
+    
+    # This perfectly standardizes 2010-2012 to match the 2013+ methodology
+    chunk = chunk[is_top_level & is_not_total].copy()
+    
+    # Clean the NAICS codes to the standard format for our crosswalk
+    # Removes trailing dashes the Census sometimes uses (e.g. '11----' -> '11')
+    chunk[col_naics] = chunk[col_naics].astype(str).str.replace(r'-+$', '', regex=True).str.strip()
+    
+    for c in [col_estab, col_emp, col_payann]:
+        chunk[c] = chunk[c].astype(str).str.replace(',', '')
+        chunk[c] = pd.to_numeric(chunk[c], errors='coerce')
+        
+    chunk = chunk.dropna(subset=[col_estab, col_emp, col_payann], how='all')
+    
+    # Local cache to prevent redundant crosswalk scans inside the chunk
+    resolved_sics_cache = {}
+    
+    for _, row in chunk.iterrows():
+        naics_code = str(row[col_naics]).strip()
+        
+        # --- PREFIX-MATCHING LOGIC ---
+        if naics_code not in resolved_sics_cache:
+            sics = set()
+            # Handle hyphenated aggregated sectors (e.g. "31-33")
+            if '-' in naics_code:
+                try:
+                    start, end = naics_code.split('-')
+                    prefixes = tuple(str(p) for p in range(int(start), int(end)+1))
+                except:
+                    prefixes = (naics_code,)
+            else:
+                prefixes = (naics_code,)
+                
+            # Scan crosswalk for any 6-digit NAICS that starts with this prefix
+            for cw_naics, cw_sics in crosswalk.items():
+                if str(cw_naics).startswith(prefixes):
+                    sics.update(cw_sics)
+            resolved_sics_cache[naics_code] = list(sics)
+            
+        sic_list = resolved_sics_cache[naics_code]
+        
+        if not sic_list:
+            continue
+            
+        state, dist = parse_geography(row[col_name])
+        bioguide_id = get_active_legislator(terms_df, state, dist, release_date)
+        
+        if bioguide_id:
+            for sic in sic_list:
+                edges.append({
+                    'bioguide_id': bioguide_id,
+                    'sic_code': sic,
+                    'release_date': release_date,
+                    'reference_year': year,
+                    'establishments': row[col_estab],
+                    'employment': row[col_emp],
+                    'annual_payroll': row[col_payann]
+                })
+                
+    return pd.DataFrame(edges)
+
+def process_cbp_file(file_path, year, release_date, crosswalk, terms_df):
+    print(f"\n[INFO] Reading Year {year} (Release: {release_date.date()})")
+    
+    chunk_size = 25000
+    chunks = []
+    for chunk in pd.read_csv(file_path, chunksize=chunk_size, dtype=str):
+        chunks.append(chunk)
+        
+    print(f"       Spawned {len(chunks)} chunks. Processing across {MAX_WORKERS} cores...")
+    
+    results = []
+    with ProcessPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        futures = {
+            executor.submit(process_chunk, c, year, release_date, crosswalk, terms_df): i 
+            for i, c in enumerate(chunks)
+        }
+        
+        for future in tqdm(as_completed(futures), total=len(chunks), desc=f"Year {year}", unit="chunk"):
+            res_df = future.result()
+            if not res_df.empty:
+                results.append(res_df)
+                
+    if results:
+        return pd.concat(results, ignore_index=True)
+    return pd.DataFrame()
+
+def main():
+    print("=====================================================")
+    print(" BUILDING INDUSTRY-GEOGRAPHICAL EDGES (CBP)")
+    print(f" Mode: Multiprocessing enabled ({MAX_WORKERS} Workers)")
+    print("=====================================================")
+    
+    cw_2012, cw_2017 = load_crosswalks()
+    release_dates = load_release_dates()
+    terms_df = load_legislators()
+    
+    all_edges = []
+    
+    for year in range(2010, 2024):
+        file_name = f"{year}_CB_estimates.csv" if year <= 2012 else f"{year}_CB_survey.csv"
+        file_path = os.path.join(CBP_DIR, file_name)
+        
+        if not os.path.exists(file_path):
+            continue
+            
+        release_date = release_dates.get(year)
+        if not release_date:
+            continue
+            
+        active_crosswalk = cw_2012 if year <= 2012 else cw_2017
+        df_edges = process_cbp_file(file_path, year, release_date, active_crosswalk, terms_df)
+        
+        if not df_edges.empty:
+            all_edges.append(df_edges)
+        
+    print("\n[INFO] Concatenating and saving final edge list...")
+    if all_edges:
+        final_df = pd.concat(all_edges, ignore_index=True)
+        os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+        final_df.to_csv(OUTPUT_FILE, index=False)
+        
+        print(f"[SUCCESS] Saved {len(final_df)} geographical-industry edges to {OUTPUT_FILE}.")
+        print(f"[STATS] Unique Legislators Mapped: {final_df['bioguide_id'].nunique()}")
+        print(f"[STATS] Unique SIC Sectors Mapped: {final_df['sic_code'].nunique()}")
+    else:
+        print("[WARNING] No edges generated.")
+
+if __name__ == "__main__":
+    main()

src/build_lobbying_events.py

@@ -0,0 +1,203 @@
+import os
+import re
+from tqdm import tqdm
+import pandas as pd
+import config
+
+def load_crosswalks():
+    """Loads NAICS->SIC, SIC->Ticker, and Legislator Mappings."""
+    print("Loading Crosswalks...")
+    
+    naics_sic = pd.read_csv(config.NAICS_TO_SIC_PATH)
+    naics_sic['NAICS'] = naics_sic['NAICS'].astype(str).str.replace(r'\.0$', '', regex=True).str.zfill(6)
+    naics_sic['SIC'] = naics_sic['SIC'].astype(str).str.replace(r'\.0$', '', regex=True).str.zfill(4)
+    naics_to_sic_map = naics_sic.groupby('NAICS')['SIC'].apply(list).to_dict()
+
+    if os.path.exists(config.COMPANY_SIC_DATA_PATH):
+        sic_data = pd.read_csv(config.COMPANY_SIC_DATA_PATH)
+        sic_data['sic'] = sic_data['sic'].astype(str).str.replace(r'\.0$', '', regex=True).str.zfill(4)
+        sic_to_ticker_map = sic_data.groupby('sic')['ticker'].apply(list).to_dict()
+    else:
+        print(f"WARNING: {config.COMPANY_SIC_DATA_PATH} not found.")
+        sic_to_ticker_map = {}
+
+    if os.path.exists(config.LEGISLATORS_CROSSWALK_PATH):
+        leg_df = pd.read_csv(config.LEGISLATORS_CROSSWALK_PATH, low_memory=False)
+        leg_map_df = leg_df[['id_icpsr', 'id_bioguide']].dropna().drop_duplicates()
+        leg_map_df['id_icpsr'] = leg_map_df['id_icpsr'].astype(int)
+        icpsr_to_bioguide = leg_map_df.set_index('id_icpsr')['id_bioguide'].to_dict()
+    else:
+        print(f"WARNING: Legislator crosswalk not found at {config.LEGISLATORS_CROSSWALK_PATH}. Voting edges will fail.")
+        icpsr_to_bioguide = {}
+
+    return naics_to_sic_map, sic_to_ticker_map, icpsr_to_bioguide
+
+def parse_bill_ids(id_str):
+    try:
+        if pd.isna(id_str): return []
+        matches = re.findall(r'[a-zA-Z0-9]+-[0-9]+', str(id_str))
+        return [m.lower().strip() for m in matches]
+    except:
+        return []
+
+def build_lobbying_events():
+    print("Building Lobbying & Voting Event Stream (Using Filing Dates)...")
+    
+    bills_df = pd.read_csv(config.LOBBYING_BILLS_PATH)
+    clients_df = pd.read_csv(config.LOBBYING_CLIENTS_PATH)
+    reports_df = pd.read_csv(config.LOBBYING_REPORTS_PATH)
+    issues_df = pd.read_csv(config.LOBBYING_ISSUES_PATH)
+    
+    has_votes = os.path.exists(config.VOTEVIEW_VOTES_PATH) and os.path.exists(config.VOTEVIEW_ROLLCALLS_PATH)
+    if has_votes:
+        print("Loading VoteView Data...")
+        votes_df = pd.read_csv(config.VOTEVIEW_VOTES_PATH)
+        rollcalls_df = pd.read_csv(config.VOTEVIEW_ROLLCALLS_PATH, low_memory=False)
+
+    bills_df['bill_id'] = bills_df['bill_id'].astype(str).str.lower().str.strip()
+    reports_df['report_uuid'] = reports_df['report_uuid'].astype(str)
+    reports_df['lob_id'] = reports_df['lob_id'].astype(str)
+    clients_df['lob_id'] = clients_df['lob_id'].astype(str)
+    
+    naics_map, sic_ticker_map, icpsr_map = load_crosswalks()
+
+    # --- Step 1: Map Clients to Tickers ---
+    clients_df['naics_str'] = clients_df['naics'].astype(str).str.replace(r'\.0$', '', regex=True).str.zfill(6)
+    client_ticker_records = []
+    
+    print("Mapping Clients to Tickers...")
+    for idx, row in tqdm(clients_df.iterrows(), total=len(clients_df), desc="Mapping Clients"):
+        target_tickers = []
+        for sic in naics_map.get(row['naics_str'], []):
+            target_tickers.extend(sic_ticker_map.get(sic, []))
+        if target_tickers:
+            for t in set(target_tickers):
+                client_ticker_records.append({'lob_id': row['lob_id'], 'ticker': t})
+                
+    client_ticker_df = pd.DataFrame(client_ticker_records)
+    print(f"Mapped {client_ticker_df['lob_id'].nunique()} clients to {client_ticker_df['ticker'].nunique()} unique tickers.")
+
+    if client_ticker_df.empty:
+        print("No clients mapped to tickers. Exiting.")
+        return
+
+    # --- Step 2: Link Reports to Bills ---
+    print("Parsing Bill IDs from Issues...")
+    tqdm.pandas(desc="Parsing Bill IDs")
+    issues_with_bills = issues_df.dropna(subset=['bill_id_agg']).copy()
+    issues_with_bills['bill_id_list'] = issues_with_bills['bill_id_agg'].progress_apply(parse_bill_ids)
+    
+    issues_exploded = issues_with_bills.explode('bill_id_list').rename(columns={'bill_id_list': 'bill_id'})
+    issues_exploded['report_uuid'] = issues_exploded['report_uuid'].astype(str)
+    issues_exploded['bill_id'] = issues_exploded['bill_id'].astype(str)
+
+    print("Merging Issues with Reports...")
+    bill_client_chain = pd.merge(
+        issues_exploded[['bill_id', 'report_uuid']], 
+        reports_df[['report_uuid', 'lob_id', 'estimated_filing_date']], 
+        on='report_uuid',
+        how='inner'
+    )
+    
+    # NEW OPTIMIZATION: Drop duplicates BEFORE merging to save massive amounts of memory
+    base_chain = bill_client_chain[['lob_id', 'bill_id', 'estimated_filing_date']].drop_duplicates()
+    ticker_bill_df = pd.merge(base_chain, client_ticker_df, on='lob_id').drop(columns=['lob_id'])
+    ticker_bill_df = ticker_bill_df.drop_duplicates()
+
+    all_events_dfs = []
+
+    # --- Step 3: Strong Edges (Sponsorship) ---
+    if getattr(config, 'INCLUDE_LOBBYING_SPONSORSHIP', True):
+        print("Generating Strong Edges (Sponsorship)...")
+        strong_df = pd.merge(ticker_bill_df, bills_df[['bill_id', 'bioguide_id']], on='bill_id', how='inner')
+        strong_df = strong_df.dropna(subset=['bioguide_id', 'estimated_filing_date'])
+        
+        # Vectorized Event Creation (Replaces the 9-minute loop)
+        strong_df = strong_df[['estimated_filing_date', 'ticker', 'bioguide_id']].drop_duplicates()
+        strong_df.rename(columns={'estimated_filing_date': 'date'}, inplace=True)
+        strong_df['event_type'] = 'LOBBY_STRONG'
+        strong_df['weight'] = 1.0
+        
+        print(f"Valid Sponsorship Connections Found: {len(strong_df)}")
+        all_events_dfs.append(strong_df)
+    else:
+        print("Skipping Strong Edges (Sponsorship) per config.")
+
+    # --- Step 4: Weak Edges (Voting) ---
+    if getattr(config, 'INCLUDE_LOBBYING_VOTING', True) and has_votes:
+        print("Generating Weak Edges (Voting)...")
+        if 'bill_number' in bills_df.columns and 'bill_number' in rollcalls_df.columns:
+            lobbied_bills = ticker_bill_df['bill_id'].unique()
+            
+            target_bills_df = bills_df[bills_df['bill_id'].isin(lobbied_bills)][['bill_id', 'bill_type', 'bill_number', 'congress_number']].copy()
+            target_bills_df['clean_type'] = target_bills_df['bill_type'].astype(str).str.replace(r'[^a-zA-Z]', '', regex=True).str.upper()
+            target_bills_df['clean_num'] = target_bills_df['bill_number'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip()
+            target_bills_df['vv_bill_number'] = target_bills_df['clean_type'] + target_bills_df['clean_num']
+            target_bills_df['congress_number'] = target_bills_df['congress_number'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip()
+            
+            rollcalls_merge = rollcalls_df[['congress', 'rollnumber', 'bill_number']].copy()
+            rollcalls_merge['vv_bill_number'] = rollcalls_merge['bill_number'].astype(str).str.replace(r'[^a-zA-Z0-9]', '', regex=True).str.upper()
+            rollcalls_merge['congress'] = rollcalls_merge['congress'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip()
+            rollcalls_merge['rollnumber'] = rollcalls_merge['rollnumber'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip()
+            
+            bill_votes_map = pd.merge(
+                target_bills_df[['bill_id', 'congress_number', 'vv_bill_number']], 
+                rollcalls_merge[['congress', 'rollnumber', 'vv_bill_number']], 
+                left_on=['congress_number', 'vv_bill_number'], 
+                right_on=['congress', 'vv_bill_number']
+            )
+            
+            bill_votes_map = bill_votes_map[~bill_votes_map['congress'].isin(['nan', 'None', ''])]
+            bill_votes_map = bill_votes_map[~bill_votes_map['rollnumber'].isin(['nan', 'None', ''])]
+            
+            yea_votes = votes_df[votes_df['cast_code'].isin([1, 2, 3])].copy()
+            yea_votes['bioguide_id'] = yea_votes['icpsr'].map(icpsr_map)
+            yea_votes = yea_votes.dropna(subset=['bioguide_id', 'congress', 'rollnumber'])
+            
+            yea_votes['congress'] = yea_votes['congress'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip()
+            yea_votes['rollnumber'] = yea_votes['rollnumber'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip()
+            yea_votes = yea_votes[~yea_votes['congress'].isin(['nan', 'None', ''])]
+            
+            print("Mapping Legislator votes to Bills...")
+            bill_to_legislator = pd.merge(
+                bill_votes_map[['bill_id', 'congress', 'rollnumber']], 
+                yea_votes[['congress', 'rollnumber', 'bioguide_id']], 
+                on=['congress', 'rollnumber']
+            )
+            
+            bill_to_legislator = bill_to_legislator[['bill_id', 'bioguide_id']].drop_duplicates()
+            
+            print("Merging Voting Records with Lobbying Clients (Chunked to prevent Memory Error)...")
+            
+            # NEW OPTIMIZATION: Process one Ticker at a time to prevent Cartesian explosion
+            weak_events_list = []
+            valid_bills_with_votes = bill_to_legislator['bill_id'].unique()
+            tb_subset = ticker_bill_df[ticker_bill_df['bill_id'].isin(valid_bills_with_votes)]
+            
+            for ticker, group in tqdm(tb_subset.groupby('ticker'), desc="Building Weak Edges"):
+                merged = pd.merge(group[['bill_id', 'estimated_filing_date']], bill_to_legislator, on='bill_id')
+                unique_edges = merged[['estimated_filing_date', 'bioguide_id']].drop_duplicates()
+                unique_edges['ticker'] = ticker
+                weak_events_list.append(unique_edges)
+                
+            if weak_events_list:
+                weak_df = pd.concat(weak_events_list, ignore_index=True)
+                weak_df.rename(columns={'estimated_filing_date': 'date'}, inplace=True)
+                weak_df['event_type'] = 'LOBBY_WEAK'
+                weak_df['weight'] = 0.5
+                print(f"Valid Voting Connections Found: {len(weak_df)}")
+                all_events_dfs.append(weak_df)
+            else:
+                print("Valid Voting Connections Found: 0")
+    else:
+        print("Skipping Weak Edges (Voting) per config.")
+
+    if all_events_dfs:
+        final_events_df = pd.concat(all_events_dfs, ignore_index=True)
+        print(f"\nSUCCESS: Generated {len(final_events_df)} total Lobbying/Voting Events.")
+        final_events_df.to_csv(config.LOBBYING_EVENTS_PATH, index=False)
+    else:
+        print("\nGenerated 0 total events.")
+
+if __name__ == "__main__":
+    build_lobbying_events()

src/config.py

@@ -0,0 +1,58 @@
+import os
+from pathlib import Path
+
+# Project Root (Relative to this config file)
+# Works whether installed as package or run from source
+try:
+    import importlib.resources as pkg_resources
+    PROJECT_ROOT = Path(pkg_resources.files("src").parent)
+except (ImportError, AttributeError):
+    PROJECT_ROOT = Path(__file__).parent.parent.resolve()
+
+# Allow override via environment variable
+PROJECT_ROOT = Path(os.getenv("CHOCOLATE_PROJECT_ROOT", PROJECT_ROOT))
+
+# Data Directories
+RAW_DATA_DIR = PROJECT_ROOT / "data" / "raw"
+PROCESSED_DATA_DIR = PROJECT_ROOT / "data" / "processed"
+LOBBYING_DIR = RAW_DATA_DIR / "lobbying_data_lobbyview"
+CAMPAIGN_FINANCE_DIR = RAW_DATA_DIR / "campaign_finance_open_secrets"
+DATA_527_DIR = RAW_DATA_DIR / "527_data_open_secrets"
+INDUSTRY_CROSSWALK_DIR = RAW_DATA_DIR / "industry_codes_NAICS"
+
+# --- Feature Flags ---
+INCLUDE_LOBBYING_SPONSORSHIP = True
+INCLUDE_LOBBYING_VOTING = True
+
+# --- Specific Data Paths ---
+# Lobbying & Votes
+LOBBYING_BILLS_PATH = LOBBYING_DIR / "bills.csv"
+LOBBYING_CLIENTS_PATH = LOBBYING_DIR / "clients.csv"
+LOBBYING_REPORTS_PATH = LOBBYING_DIR / "reports.csv"
+LOBBYING_ISSUES_PATH = LOBBYING_DIR / "issue_text.csv"
+
+# VoteView Paths
+VOTEVIEW_VOTES_PATH = RAW_DATA_DIR / "HSall_votes.csv"
+VOTEVIEW_ROLLCALLS_PATH = RAW_DATA_DIR / "HSall_rollcalls.csv"
+
+# Campaign Finance Paths
+CAMPAIGN_PACS_PATTERN = "pacs*.csv"
+DATA_527_EXPENDITURES_PATH = DATA_527_DIR / "Expenditures.csv"
+DATA_527_COMMITTEES_PATH = DATA_527_DIR / "Cmtes527.csv"
+
+# Crosswalks
+NAICS_TO_SIC_PATH = INDUSTRY_CROSSWALK_DIR / "2017-NAICS-to-SIC-Crosswalk.csv"
+COMPANY_SIC_DATA_PATH = RAW_DATA_DIR / "company_sic_data.csv" 
+LEGISLATORS_CROSSWALK_PATH = RAW_DATA_DIR / "congress_terms_all_github.csv"
+
+# Outputs
+LOBBYING_EVENTS_PATH = PROCESSED_DATA_DIR / "events_lobbying.csv"
+CAMPAIGN_FINANCE_EVENTS_PATH = PROCESSED_DATA_DIR / "events_campaign_finance.csv"
+
+# Make sure local directories exist
+PROCESSED_DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+# Convert to strings for backward compatibility
+PROJECT_ROOT = str(PROJECT_ROOT)
+RAW_DATA_DIR = str(RAW_DATA_DIR)
+PROCESSED_DATA_DIR = str(PROCESSED_DATA_DIR)

src/temporal_data.py

@@ -0,0 +1,865 @@
+"""
+src/temporal_data.py
+Phase 1: Data Ingestion and Standardization
+"""
+import pandas as pd
+import numpy as np
+import os
+from sklearn.preprocessing import MultiLabelBinarizer
+import pyarrow.parquet as pq
+import argparse
+import torch
+import duckdb
+import gc
+try:
+    from torch_geometric.data import TemporalData
+except ImportError:
+    print("[WARNING] torch_geometric not found. Phase 4 will fail without PyG installed.")
+
+# --- CONFIGURATION PANEL ---
+CONFIG = {
+    # 1. Base Directories
+    "DATA_DIR": "data",
+    "PROCESSED_DIR": "data/processed",
+    "EDGE_OUT_DIR": "data/processed/master_edges_parquet",
+    "PYG_OUT_DIR": "data/processed/pyg_graph",
+
+    # 2. Input File Paths (Relative to DATA_DIR)
+    "FILES": {
+        "trades": "cropped/ml_dataset_continuous.csv",
+        "lobbying": "processed/events_lobbying.csv",
+        "camp_fin": "processed/events_campaign_finance.csv",
+        "geo": "processed/events_geographical_industry.csv",
+        "company_sic": "cropped/company_sic_data.csv",
+        "committee": "cropped/committee_assignments.csv",
+        "sec_financials": "cropped/sec_quarterly_financials.csv"
+    },
+
+    # 3. Graph Assembly Toggles
+    "INCLUDE_EDGES": {
+        "trades": False,      
+        "lobbying": True,
+        "camp_fin": True,
+        "geo": True
+    },
+    
+    "START_DATE": "2021-01-01"
+}
+# ---------------------------
+
+# --- Helper for Strict Schema Validation ---
+def validate_columns(df: pd.DataFrame, required_columns: list, dataset_name: str):
+    """Raises a clear ValueError if expected columns are missing."""
+    missing = [col for col in required_columns if col not in df.columns]
+    if missing:
+        raise ValueError(f"[{dataset_name}] Missing required columns: {missing}\n"
+                         f"Available columns: {list(df.columns)}")
+
+def load_and_standardize_events(data_dir="data"):
+    """
+    PHASE 1: Load the four primary data sources and map them to a unified schema.
+    Returns standardized pandas DataFrames for each event type.
+    """
+    print("==================================================")
+    print("PHASE 1: DATA INGESTION & STANDARDIZATION")
+    print("==================================================")
+
+    # ---------------------------------------------------------
+    # 1.1 TARGET EDGES (Trades)
+    # ---------------------------------------------------------
+    path_trades = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["trades"])
+    print(f"Loading Trades from: {path_trades}")
+    df_trades = pd.read_csv(path_trades)
+    
+    # 17 market features + 3 trade mechanics
+    market_features = [
+        'vol_20d', 'vol_60d', 'vol_120d', 'vol_252d', 'vol_of_vol_60d', 'vol_trend', 'idio_vol_60d',
+        'mom_60d', 'mom_252d', 'reversal_21d',
+        'beta_20d', 'beta_60d', 'downside_beta', 'excess_vol', 'max_dd_60d', 'skew_60d', 'sharpe_60d'
+    ]
+    trade_features = ['Trade_Size_USD', 'Filing_Gap', 'Transaction'] # Transaction = Buy/Sell Ratio or is_buy
+    
+    req_trade_cols = ['BioGuideID', 'Matched_Ticker', 'Filed'] + trade_features + market_features
+    validate_columns(df_trades, req_trade_cols, "Trades")
+
+    df_trades = df_trades.rename(columns={
+        'BioGuideID': 'src',
+        'Matched_Ticker': 'dst',
+        'Filed': 'time'
+    })
+    df_trades['event_type'] = 0
+    
+    # Calculate Label: e.g., Top 25% 6M Excess Return = 1. 
+    if 'Excess_Return_6M' in df_trades.columns:
+        threshold = df_trades['Excess_Return_6M'].quantile(0.75)
+        df_trades['y'] = (df_trades['Excess_Return_6M'] >= threshold).astype(int)
+    else:
+        print("[WARNING] 'Excess_Return_6M' not found. Setting dummy target 'y' = 0")
+        df_trades['y'] = 0
+
+    print(f" -> Trades loaded successfully. Shape: {df_trades.shape}")
+
+    # ---------------------------------------------------------
+    # 1.2 LOBBYING EVENTS
+    # ---------------------------------------------------------
+    if CONFIG["INCLUDE_EDGES"].get("lobbying", True):
+        path_lobbying = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["lobbying"])
+        df_lobbying = pd.read_csv(path_lobbying)
+
+        path_lobbying = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["lobbying"])
+        print(f"Loading Lobbying from: {path_lobbying}")
+        df_lobbying = pd.read_csv(path_lobbying)
+        
+        # Depending on how it was saved, the time column might be 'estimated_filing_date' or 'date'
+        time_col_lobby = 'estimated_filing_date' if 'estimated_filing_date' in df_lobbying.columns else 'date'
+        
+        validate_columns(df_lobbying, ['bioguide_id', 'ticker', time_col_lobby, 'event_type'], "Lobbying")
+
+        df_lobbying = df_lobbying.rename(columns={
+            'bioguide_id': 'src',
+            'ticker': 'dst',
+            time_col_lobby: 'time'
+        })
+        
+        # Extract structural flags
+        df_lobbying['is_sponsorship'] = (df_lobbying['event_type'] == 'LOBBY_STRONG').astype(float)
+        df_lobbying['voted_yea'] = (df_lobbying['event_type'] == 'LOBBY_WEAK').astype(float)
+        df_lobbying['event_type'] = 1 # Override with integer event code
+        
+        print(f" -> Lobbying loaded successfully. Shape: {df_lobbying.shape}")
+    
+    else:
+        print(" -> [CONFIG] Skipping Lobbying edges...")
+        df_lobbying = pd.DataFrame()
+
+    # ---------------------------------------------------------
+    # 1.3 CAMPAIGN FINANCE EVENTS
+    # ---------------------------------------------------------
+    # ---------------------------------------------------------
+    if CONFIG["INCLUDE_EDGES"].get("camp_fin", True):
+        path_camp_fin = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["camp_fin"])
+        df_camp_fin = pd.read_csv(path_camp_fin)
+    
+        time_col_cf = 'estimated_filing_date' if 'estimated_filing_date' in df_camp_fin.columns else 'date'
+        validate_columns(df_camp_fin, ['bioguide_id', 'industry_code', time_col_cf, 'weight'], "Campaign Finance")
+
+        df_camp_fin = df_camp_fin.rename(columns={
+            'bioguide_id': 'src',
+            'industry_code': 'dst_temp', # Needs broadcasting
+            time_col_cf: 'time',
+            'weight': 'Fin_Amt' # Assuming donation amount
+        })
+        df_camp_fin['event_type'] = 2
+
+        print(f" -> Campaign Finance loaded successfully. Shape: {df_camp_fin.shape}")
+    
+    else:
+        print(" -> [CONFIG] Skipping Campaign Finance edges...")
+        df_camp_fin = pd.DataFrame()
+
+    # 1.4 GEO-INDUSTRIAL EDGES
+    # ---------------------------------------------------------
+    if CONFIG["INCLUDE_EDGES"].get("geo", True):
+        path_geo = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["geo"])
+        df_geo = pd.read_csv(path_geo)
+    
+        validate_columns(df_geo, ['bioguide_id', 'sic_code', 'release_date', 'establishments', 'employment', 'annual_payroll'], "Geo-Industrial")
+
+        df_geo = df_geo.rename(columns={
+            'bioguide_id': 'src',
+            'sic_code': 'dst_temp', # Needs broadcasting
+            'release_date': 'time'
+        })
+        
+        # Normalizing economic weight (log-scaling as per Appendix B.2.3)
+        df_geo['Geo_Weight'] = np.log1p(df_geo['employment'].fillna(0))
+        df_geo['event_type'] = 3
+
+        print(f" -> Geo-Industrial loaded successfully. Shape: {df_geo.shape}")
+
+    else:
+        print(" -> [CONFIG] Skipping Geo-Industrial edges...")
+        df_geo = pd.DataFrame()
+
+    # ---------------------------------------------------------
+    # 1.5 LOAD DICTIONARIES FOR BROADCASTING (Phase 2 Prep)
+    # ---------------------------------------------------------
+    print("Loading Crosswalk Dictionaries...")
+    path_cw_2012 = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2012-NAICS-to-SIC-crosswalk.csv")
+    path_cw_2017 = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2017-NAICS-to-SIC-crosswalk.csv")
+    path_cw_cat = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2013-CAT_to_SIC_to_NAICS_mappings.csv")
+    
+    cw_2012 = pd.read_csv(path_cw_2012)
+    cw_2017 = pd.read_csv(path_cw_2017)
+    cw_cat = pd.read_csv(path_cw_cat)
+    
+    validate_columns(cw_cat, ['OpenSecretsCatcode', 'SICcode'], "CAT to SIC Crosswalk")
+    print(" -> All Data and Crosswalks successfully ingested.")
+    print("==================================================\n")
+
+    return df_trades, df_lobbying, df_camp_fin, df_geo, cw_2012, cw_2017, cw_cat
+
+def broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat, data_dir="data"):
+    """
+    PHASE 2: Memory-Optimized Sector Broadcasting & Tensor Alignment
+    """
+    print("==================================================")
+    print("PHASE 2: OPTIMIZED BROADCASTING & ALIGNMENT")
+    print("==================================================")
+
+    # 1. Load and Clean Company SIC Master List
+    path_company_sic = os.path.join(data_dir, "cropped", "company_sic_data.csv")
+    df_comp_sic = pd.read_csv(path_company_sic)
+    df_comp_sic = df_comp_sic.drop_duplicates(subset=['ticker', 'sic'])
+    df_comp_sic['sic'] = df_comp_sic['sic'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip().str.zfill(4)
+
+    # 2. Fix Campaign Finance Mapping (Clean CAT/SIC strings)
+    df_camp_fin['dst_temp'] = df_camp_fin['dst_temp'].astype(str).str.strip().str.upper()
+    cw_cat['OpenSecretsCatcode'] = cw_cat['OpenSecretsCatcode'].astype(str).str.strip().str.upper()
+    cw_cat['SICcode'] = cw_cat['SICcode'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip().str.zfill(4)
+
+    # ---------------------------------------------------------
+    # 2.1 THE "BROADCAST" MECHANISM
+    # ---------------------------------------------------------
+    print("Broadcasting Geo-Industrial edges...")
+    df_geo['dst_temp'] = df_geo['dst_temp'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip().str.zfill(4)
+    df_geo = df_geo.merge(df_comp_sic[['sic', 'ticker']], left_on='dst_temp', right_on='sic', how='inner')
+    df_geo = df_geo.rename(columns={'ticker': 'dst'}).drop(columns=['dst_temp', 'sic'])
+
+    print("Broadcasting Campaign Finance edges...")
+    df_camp_fin = df_camp_fin.merge(cw_cat[['OpenSecretsCatcode', 'SICcode']], 
+                                   left_on='dst_temp', right_on='OpenSecretsCatcode', how='inner')
+    df_camp_fin = df_camp_fin.merge(df_comp_sic[['sic', 'ticker']], 
+                                   left_on='SICcode', right_on='sic', how='inner')
+    df_camp_fin = df_camp_fin.rename(columns={'ticker': 'dst'}).drop(columns=['dst_temp', 'OpenSecretsCatcode', 'SICcode', 'sic'])
+
+    print(f" -> Geo edges: {len(df_geo)} | Fin edges: {len(df_camp_fin)}")
+
+    # ---------------------------------------------------------
+    # 2.2 UNIFIED EDGE ATTRIBUTE TENSOR (msg)
+    # ---------------------------------------------------------
+    # RESTORED: Map categorical Trade variables to numeric BEFORE downcasting
+    print("Mapping categorical Trade variables to numeric...")
+    if df_trades['Transaction'].dtype == object:
+        df_trades['Transaction'] = df_trades['Transaction'].astype(str).str.lower().apply(
+            lambda x: 1.0 if 'purchase' in x or 'buy' in x else 0.0
+        )
+
+    size_map = {
+        '$1,001 - $15,000': 1.0,
+        '$15,001 - $50,000': 2.0,
+        '$50,001 - $100,000': 3.0,
+        '$100,001 - $250,000': 4.0,
+        '$250,001 - $500,000': 5.0,
+        '$500,001 - $1,000,000': 6.0,
+        '$1,000,001 - $5,000,000': 7.0,
+        '$5,000,001 - $25,000,000': 8.0,
+        '$25,000,001 - $50,000,000': 9.0,
+        'Over $50,000,000': 10.0
+    }
+    if df_trades['Trade_Size_USD'].dtype == object:
+        df_trades['Trade_Size_USD'] = df_trades['Trade_Size_USD'].map(size_map).fillna(0.0)
+
+    market_features = [
+        'vol_20d', 'vol_60d', 'vol_120d', 'vol_252d', 'vol_of_vol_60d', 'vol_trend', 'idio_vol_60d',
+        'mom_60d', 'mom_252d', 'reversal_21d',
+        'beta_20d', 'beta_60d', 'downside_beta', 'excess_vol', 'max_dd_60d', 'skew_60d', 'sharpe_60d'
+    ]
+    all_msg_cols = ['Trade_Size_USD', 'Filing_Gap', 'Transaction', 'is_sponsorship', 'voted_yea', 'Fin_Amt', 'Geo_Weight'] + market_features
+    
+    def align_schema(df):
+        # Broadcast scalar directly to bypass pandas array-copying overhead
+        for col in all_msg_cols:
+            if col not in df.columns:
+                df[col] = np.float32(0.0)
+            elif df[col].dtype != 'float32':
+                # Convert existing columns to float32
+                df[col] = df[col].astype('float32')
+        return df
+    
+    print("Aligning D=24 schemas and downcasting to float32...")
+    df_trades = align_schema(df_trades)
+
+    # 2. Fix the missing target label ('y') for structural edges
+    df_lobbying['y'] = -1
+    df_camp_fin['y'] = -1
+    df_geo['y'] = -1
+    if 'y' not in df_trades.columns: 
+        df_trades['y'] = -1
+
+    df_lobbying['y'] = -1
+    df_camp_fin['y'] = -1
+    df_geo['y'] = -1
+    if 'y' not in df_trades.columns: 
+        df_trades['y'] = -1
+
+    # ---------------------------------------------------------
+    # 3. OUT-OF-CORE ALIGNMENT & PARQUET WRITING
+    # ---------------------------------------------------------
+    import gc
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    output_dir = CONFIG["EDGE_OUT_DIR"]
+    os.makedirs(output_dir, exist_ok=True)
+    print(f"Writing chunks directly to Parquet at: {output_dir}")
+
+    base_cols = ['src', 'dst', 'time', 'event_type', 'y']
+
+    # Load unpadded, "skinny" dataframes into the queue
+    datasets = [
+        ("trades", df_trades),
+        ("lobbying", df_lobbying),
+        ("camp_fin", df_camp_fin),
+        ("geo", df_geo)
+    ]
+
+    # Destroy the loose global references immediately 
+    del df_trades, df_lobbying, df_camp_fin, df_geo
+    gc.collect()
+
+    # Process 5 million rows at a time (~480 MB per chunk, extremely safe for RAM)
+    chunk_size = 5_000_000 
+
+    for i in range(len(datasets)):
+        name, df_full = datasets[i]
+        
+        out_path = os.path.join(output_dir, f"edges_{name}.parquet")
+        writer = None
+        
+        # 1. Slice, format, pad, and append in chunks
+        for start in range(0, len(df_full), chunk_size):
+            end = min(start + chunk_size, len(df_full))
+            df_chunk = df_full.iloc[start:end].copy()
+            
+            # --- MOVED INSIDE THE CHUNK LOOP ---
+            # Convert to datetime and sort LOCALLY in this 5M row chunk
+            df_chunk['time'] = pd.to_datetime(df_chunk['time'])
+            df_chunk = df_chunk.sort_values(by='time').reset_index(drop=True)
+            # -----------------------------------
+            
+            # Apply schema alignment locally to this small chunk
+            for col in all_msg_cols:
+                if col not in df_chunk.columns:
+                    df_chunk[col] = np.float32(0.0)
+                else:
+                    df_chunk[col] = df_chunk[col].astype('float32')
+            
+            # Filter down to base + msg cols
+            df_chunk = df_chunk[base_cols + all_msg_cols]
+            
+            # Append to Parquet file
+            table = pa.Table.from_pandas(df_chunk)
+            if writer is None:
+                # Initialize the writer with the schema of the first padded chunk
+                writer = pq.ParquetWriter(out_path, table.schema)
+            writer.write_table(table)
+            
+            # Destroy the padded chunk to free RAM
+            del df_chunk
+            gc.collect()
+            
+        if writer:
+            writer.close()
+            
+        print(f" -> Saved {name} ({len(df_full)} rows) to {out_path}")
+        
+        # 2. Destroy the reference to the full dataset before loading the next one
+        datasets[i] = None 
+        del df_full
+        gc.collect()
+
+    print(" -> Master Edge Parquet chunks successfully written.")
+    print("==================================================\n")
+    
+    return output_dir, all_msg_cols
+
+# ==========================================
+# PHASE 3: NODE FEATURE EXTRACTION
+# ==========================================
+
+SEC_FACTS = [
+    "NetIncomeLoss", "StockholdersEquity", "EarningsPerShareBasic", 
+    "EarningsPerShareDiluted", "IncomeTaxExpenseBenefit", 
+    "CashAndCashEquivalentsAtCarryingValue", "WeightedAverageNumberOfSharesOutstandingBasic", 
+    "OperatingIncomeLoss", "WeightedAverageNumberOfDilutedSharesOutstanding", 
+    "Assets", "LiabilitiesAndStockholdersEquity", "InterestExpense", 
+    "RetainedEarningsAccumulatedDeficit", "NetCashProvidedByUsedInOperatingActivities", 
+    "NetCashProvidedByUsedInFinancingActivities", "NetCashProvidedByUsedInInvestingActivities", 
+    "Liabilities", "CommonStockValue", "AccumulatedOtherComprehensiveIncomeLossNetOfTax", 
+    "PropertyPlantAndEquipmentNet", "Revenues", "AssetsCurrent", 
+    "LiabilitiesCurrent", "OperatingExpenses", "GrossProfit", 
+    "PaymentsToAcquirePropertyPlantAndEquipment", "Goodwill", 
+    "AmortizationOfIntangibleAssets", "SellingGeneralAndAdministrativeExpense", 
+    "AccountsPayableCurrent", "CommonStockDividendsPerShareDeclared", 
+    "NonoperatingIncomeExpense", "OtherAssetsNoncurrent", 
+    "AdditionalPaidInCapital", "AccountsReceivableNetCurrent", 
+    "ResearchAndDevelopmentExpense"
+]
+
+def map_sic_to_division(sic_code):
+    """Maps a 4-digit SIC code to its 10 parent divisions (0-9)."""
+    try:
+        sic = int(sic_code)
+        if sic < 1000: return 0   # Agriculture
+        elif sic < 1500: return 1  # Mining
+        elif sic < 1800: return 2  # Construction
+        elif sic < 4000: return 3  # Manufacturing
+        elif sic < 5000: return 4  # Transportation/Utilities
+        elif sic < 5200: return 5  # Wholesale Trade
+        elif sic < 6000: return 6  # Retail Trade
+        elif sic < 6800: return 7  # Finance, Insurance, RE
+        elif sic < 9000: return 8  # Services
+        else: return 9             # Public Admin
+    except:
+        return 9 
+
+def process_node_features(data_dir="data/", processed_dir="data/processed/"):
+    """
+    Phase 3: Generate and save temporally aligned node features for politicians and companies.
+    """
+    pol_parquet_path = os.path.join(processed_dir, "politician_features.parquet")
+    comp_parquet_path = os.path.join(processed_dir, "company_features.parquet")
+
+    if os.path.exists(pol_parquet_path) and os.path.exists(comp_parquet_path):
+        print(" -> Found existing node feature parquets. Skipping Phase 3 generation...")
+        return pol_parquet_path, comp_parquet_path
+
+    print("==================================================")
+    print("PHASE 3: NODE FEATURE EXTRACTION")
+    print("==================================================")
+
+    # --- Politician Snapshots (x_src) ---
+    print(" -> Processing Politician Features...")
+    df_com = pd.read_csv(os.path.join(data_dir, "cropped/committee_assignments.csv"))
+    df_com['Committees'] = df_com['Committees'].fillna('').astype(str).str.split(r';\s*')
+    
+    mlb = MultiLabelBinarizer()
+    encoded_com = mlb.fit_transform(df_com['Committees'])
+    df_com_encoded = pd.DataFrame(encoded_com, columns=[f"Com_{c}" for c in mlb.classes_])
+    df_pol = pd.concat([df_com.drop('Committees', axis=1), df_com_encoded], axis=1)
+
+    # --- Company Snapshots (x_dst) ---
+    print(" -> Processing Company Features (SEC & SIC)...")
+    df_sec = pd.read_csv(os.path.join(data_dir, "cropped/sec_quarterly_financials.csv"))
+    df_sec['FiledDate'] = pd.to_datetime(df_sec['FiledDate'])
+    
+    df_sec = df_sec[df_sec['Fact'].isin(SEC_FACTS)]
+    df_sec = df_sec.drop_duplicates(subset=['Ticker', 'FiledDate', 'Fact'], keep='last')
+    
+    df_comp = df_sec.pivot(index=['Ticker', 'FiledDate'], columns='Fact', values='Value').reset_index()
+    for fact in SEC_FACTS:
+        if fact not in df_comp.columns:
+            df_comp[fact] = np.nan
+            
+    df_comp = df_comp[['Ticker', 'FiledDate'] + SEC_FACTS].sort_values(['Ticker', 'FiledDate'])
+    df_comp = df_comp.groupby('Ticker').ffill().fillna(0.0)
+    
+    for col in SEC_FACTS:
+        df_comp[col] = np.sign(df_comp[col]) * np.log1p(np.abs(df_comp[col]))
+
+    df_sic = pd.read_csv(os.path.join(data_dir, "cropped/company_sic_data.csv"))
+    df_sic['sic_division'] = df_sic['sic'].apply(map_sic_to_division)
+    sic_dummies = pd.get_dummies(df_sic['sic_division'], prefix='SIC_Div')
+    
+    for i in range(10):
+        if f'SIC_Div_{i}' not in sic_dummies.columns:
+            sic_dummies[f'SIC_Div_{i}'] = 0
+            
+    df_sic = pd.concat([df_sic[['ticker']], sic_dummies[[f'SIC_Div_{i}' for i in range(10)]].astype(np.float32)], axis=1)
+    df_sic = df_sic.rename(columns={'ticker': 'Ticker'})
+    
+    df_comp = df_comp.merge(df_sic, on='Ticker', how='left')
+    sic_cols = [f'SIC_Div_{i}' for i in range(10)]
+    df_comp[sic_cols] = df_comp[sic_cols].fillna(0.0)
+
+    print(" -> Saving Phase 3 Parquets...")
+    df_pol.to_parquet(pol_parquet_path)
+    df_comp.to_parquet(comp_parquet_path)
+    
+    return pol_parquet_path, comp_parquet_path
+
+# ==========================================
+# PHASE 3: NODE FEATURE EXTRACTION
+# ==========================================
+
+SEC_FACTS = [
+    "NetIncomeLoss", "StockholdersEquity", "EarningsPerShareBasic", 
+    "EarningsPerShareDiluted", "IncomeTaxExpenseBenefit", 
+    "CashAndCashEquivalentsAtCarryingValue", "WeightedAverageNumberOfSharesOutstandingBasic", 
+    "OperatingIncomeLoss", "WeightedAverageNumberOfDilutedSharesOutstanding", 
+    "Assets", "LiabilitiesAndStockholdersEquity", "InterestExpense", 
+    "RetainedEarningsAccumulatedDeficit", "NetCashProvidedByUsedInOperatingActivities", 
+    "NetCashProvidedByUsedInFinancingActivities", "NetCashProvidedByUsedInInvestingActivities", 
+    "Liabilities", "CommonStockValue", "AccumulatedOtherComprehensiveIncomeLossNetOfTax", 
+    "PropertyPlantAndEquipmentNet", "Revenues", "AssetsCurrent", 
+    "LiabilitiesCurrent", "OperatingExpenses", "GrossProfit", 
+    "PaymentsToAcquirePropertyPlantAndEquipment", "Goodwill", 
+    "AmortizationOfIntangibleAssets", "SellingGeneralAndAdministrativeExpense", 
+    "AccountsPayableCurrent", "CommonStockDividendsPerShareDeclared", 
+    "NonoperatingIncomeExpense", "OtherAssetsNoncurrent", 
+    "AdditionalPaidInCapital", "AccountsReceivableNetCurrent", 
+    "ResearchAndDevelopmentExpense"
+]
+
+def map_sic_to_division(sic_code):
+    """Maps a 4-digit SIC code to its 10 parent divisions (0-9)."""
+    try:
+        sic = int(sic_code)
+        if sic < 1000: return 0   # Agriculture
+        elif sic < 1500: return 1  # Mining
+        elif sic < 1800: return 2  # Construction
+        elif sic < 4000: return 3  # Manufacturing
+        elif sic < 5000: return 4  # Transportation/Utilities
+        elif sic < 5200: return 5  # Wholesale Trade
+        elif sic < 6000: return 6  # Retail Trade
+        elif sic < 6800: return 7  # Finance, Insurance, RE
+        elif sic < 9000: return 8  # Services
+        else: return 9             # Public Admin
+    except:
+        return 9 
+
+# --- Constants & Configurations ---
+CBP_RELEASE_DATES = {
+    2023: "2025-06-26", 2022: "2024-06-27", 2021: "2023-04-20", 
+    2020: "2022-04-28", 2019: "2021-04-22", 2018: "2020-06-25", 
+    2017: "2019-11-21", 2016: "2018-04-19", 2015: "2017-04-20", 
+    2014: "2016-04-24", 2013: "2015-04-23", 2012: "2014-05-29", 
+    2011: "2013-04-30", 2010: "2012-06-26"
+}
+
+STATE_ABBREV = {
+    'Alabama': 'AL', 'Alaska': 'AK', 'Arizona': 'AZ', 'Arkansas': 'AR', 'California': 'CA',
+    'Colorado': 'CO', 'Connecticut': 'CT', 'Delaware': 'DE', 'Florida': 'FL', 'Georgia': 'GA',
+    'Hawaii': 'HI', 'Idaho': 'ID', 'Illinois': 'IL', 'Indiana': 'IN', 'Iowa': 'IA',
+    'Kansas': 'KS', 'Kentucky': 'KY', 'Louisiana': 'LA', 'Maine': 'ME', 'Maryland': 'MD',
+    'Massachusetts': 'MA', 'Michigan': 'MI', 'Minnesota': 'MN', 'Mississippi': 'MS',
+    'Missouri': 'MO', 'Montana': 'MT', 'Nebraska': 'NE', 'Nevada': 'NV', 'New Hampshire': 'NH',
+    'New Jersey': 'NJ', 'New Mexico': 'NM', 'New York': 'NY', 'North Carolina': 'NC',
+    'North Dakota': 'ND', 'Ohio': 'OH', 'Oklahoma': 'OK', 'Oregon': 'OR', 'Pennsylvania': 'PA',
+    'Rhode Island': 'RI', 'South Carolina': 'SC', 'South Dakota': 'SD', 'Tennessee': 'TN',
+    'Texas': 'TX', 'Utah': 'UT', 'Vermont': 'VT', 'Virginia': 'VA', 'Washington': 'WA',
+    'West Virginia': 'WV', 'Wisconsin': 'WI', 'Wyoming': 'WY', 'District of Columbia': 'DC'
+}
+
+# (Keep SEC_FACTS list and map_sic_to_division helper exactly as you had them)
+
+def process_node_features(data_dir="data/", processed_dir="data/processed/"):
+    """Phase 3: Generate and save standardized node features."""
+    import re
+    pol_path = os.path.join(processed_dir, "politician_features.parquet")
+    comp_path = os.path.join(processed_dir, "company_features.parquet")
+    cbp_out_path = os.path.join(processed_dir, "district_economics_cbp.parquet")
+
+    if all(os.path.exists(p) for p in [pol_path, comp_path, cbp_out_path]):
+        print(" -> Found all node feature parquets. Skipping Phase 3...")
+        return pol_path, comp_path
+
+    print("==================================================")
+    print("PHASE 3: NODE FEATURE EXTRACTION")
+    print("==================================================")
+
+    # --- 1. POLITICIAN STATIC (Committees & Party) ---
+    print(" -> Processing Politician Static Features...")
+    df_com = pd.read_csv(os.path.join(data_dir, "cropped/committee_assignments.csv"))
+    df_com['Committees'] = df_com['Committees'].fillna('').astype(str).str.split(r';\s*')
+    mlb = MultiLabelBinarizer()
+    encoded_com = mlb.fit_transform(df_com['Committees'])
+    df_pol_static = pd.concat([df_com.drop('Committees', axis=1), 
+                               pd.DataFrame(encoded_com, columns=[f"Com_{c}" for c in mlb.classes_])], axis=1)
+    df_pol_static['District_Num'] = df_pol_static['District'].astype(str).str.extract(r'(\d+)').fillna('0')
+
+    # --- 2. DISTRICT ECONOMICS (NAICS Schema-Agnostic) ---
+    print(" -> Processing CBP District Economics (Handling 2012/2017 NAICS Schema)...")
+    cbp_dir = os.path.join(data_dir, "cropped/district_industries")
+    cbp_dfs = []
+    
+    # Nested helper to parse "Congressional District 1 (119th Congress), Alabama"
+    def _parse_geo(name):
+        try:
+            match = re.search(r'(?:District\s|at Large)(\d+)?.*?,\s*(.*)', str(name))
+            if match:
+                dist = match.group(1) if match.group(1) else '0'
+                state = STATE_ABBREV.get(match.group(2).strip(), 'XX')
+                return state, str(int(dist))
+        except: pass
+        return "XX", "-1"
+
+    for year, release_date in CBP_RELEASE_DATES.items():
+        file_name = f"{year}_CB_estimates.csv" if year <= 2012 else f"{year}_CB_esurvey.csv"
+        file_path = os.path.join(cbp_dir, file_name)
+        if not os.path.exists(file_path): continue
+            
+        df_year = pd.read_csv(file_path, low_memory=False)
+        df_year.columns = [c.split('(')[-1].replace(')', '').strip() if '(' in c else c for c in df_year.columns]
+        
+        # Dynamically grabs NAICS2012 or NAICS2017
+        naics_col = next((c for c in df_year.columns if 'NAICS' in c), None)
+        if not naics_col: continue
+            
+        df_year = df_year[['NAME', naics_col, 'EMP']].copy()
+        df_year.rename(columns={naics_col: 'Sector_Raw'}, inplace=True)
+        df_year['EMP'] = pd.to_numeric(df_year['EMP'], errors='coerce').fillna(0)
+        df_year['ReleaseDate'] = pd.to_datetime(release_date)
+        
+        # Explicitly call the nested _parse_geo function
+        df_year[['State', 'District']] = pd.DataFrame(df_year['NAME'].apply(_parse_geo).tolist(), index=df_year.index)
+        df_year['Sector'] = df_year['Sector_Raw'].astype(str).str[:2]
+        cbp_dfs.append(df_year)
+
+    if cbp_dfs:
+        df_cbp = pd.concat(cbp_dfs, ignore_index=True)
+        df_cbp_pivot = df_cbp.pivot_table(index=['State', 'District', 'ReleaseDate'], 
+                                          columns='Sector', values='EMP', aggfunc='sum').reset_index()
+        
+        # Forward fill 24-dim economics vector
+        df_cbp_pivot = df_cbp_pivot.sort_values(['State', 'District', 'ReleaseDate'])
+        sector_cols = [c for c in df_cbp_pivot.columns if c not in ['State', 'District', 'ReleaseDate']]
+        
+        # Prefix the NAICS columns for clarity
+        df_cbp_pivot.rename(columns={c: f"NAICS_EMP_{c}" for c in sector_cols}, inplace=True)
+        naics_prefixed = [f"NAICS_EMP_{c}" for c in sector_cols]
+        
+        df_cbp_pivot[naics_prefixed] = df_cbp_pivot.groupby(['State', 'District'])[naics_prefixed].ffill().fillna(0.0)
+        
+        df_cbp_pivot.to_parquet(cbp_out_path)
+        print(f"   -> Saved District Economics (Dims: {len(naics_prefixed)})")
+
+    # --- 3. COMPANY SNAPSHOTS (SEC & SIC) ---
+    print(" -> Processing Company Features (SEC & SIC)...")
+    df_sec = pd.read_csv(os.path.join(data_dir, "cropped/sec_quarterly_financials.csv"))
+    df_sec['FiledDate'] = pd.to_datetime(df_sec['FiledDate'])
+    df_sec = df_sec[df_sec['Fact'].isin(SEC_FACTS)].drop_duplicates(subset=['Ticker', 'FiledDate', 'Fact'], keep='last')
+    
+    df_comp = df_sec.pivot(index=['Ticker', 'FiledDate'], columns='Fact', values='Value').reset_index()
+    for fact in SEC_FACTS:
+        if fact not in df_comp.columns: df_comp[fact] = np.nan
+    df_comp = df_comp[['Ticker', 'FiledDate'] + SEC_FACTS].sort_values(['Ticker', 'FiledDate'])
+    
+    df_comp[SEC_FACTS] = df_comp.groupby('Ticker')[SEC_FACTS].ffill().fillna(0.0)
+    for col in SEC_FACTS:
+        df_comp[col] = np.sign(df_comp[col]) * np.log1p(np.abs(df_comp[col]))
+
+    df_sic = pd.read_csv(os.path.join(data_dir, "cropped/company_sic_data.csv"))
+    df_sic['sic_division'] = df_sic['sic'].apply(map_sic_to_division)
+    sic_dummies = pd.get_dummies(df_sic['sic_division'], prefix='SIC_Div')
+    for i in range(10):
+        if f'SIC_Div_{i}' not in sic_dummies.columns: sic_dummies[f'SIC_Div_{i}'] = 0
+    df_sic_proc = pd.concat([df_sic[['ticker']], sic_dummies[[f'SIC_Div_{i}' for i in range(10)]]], axis=1).rename(columns={'ticker': 'Ticker'})
+    df_comp = df_comp.merge(df_sic_proc, on='Ticker', how='left').fillna(0.0)
+
+    # SAVE ALL
+    print(" -> Saving Phase 3 Parquets...")
+    df_pol_static.to_parquet(pol_path)
+    df_comp.to_parquet(comp_path)
+    
+    return pol_path, comp_path
+
+# ==========================================
+# PHASE 4: ASSEMBLY & PYG VALIDATION
+# ==========================================
+
+# ==========================================
+# PHASE 4: ASSEMBLY & PYG VALIDATION (OUT-OF-CORE)
+# ==========================================
+
+# ==========================================
+# PHASE 4: OUT-OF-CORE TEMPORAL SHARDING
+# ==========================================
+
+def generate_hillstreet_dataset(edge_dir="data/processed/master_edges_parquet", start_date="2012-07-01", include_structural_edges=True):
+    """
+    PHASE 4: Sharded conversion to PyTorch Geometric TemporalData.
+    Anchored to the true STOCK Act start date: July 2012.
+    """
+    print("==================================================")
+    print("PHASE 4: OUT-OF-CORE TEMPORAL SHARDING")
+    print("==================================================")
+
+    # 4.1 VALIDATE FILES
+    edge_files = [
+        "edges_trades.parquet",
+        "edges_lobbying.parquet", 
+        "edges_camp_fin.parquet", 
+        "edges_geo.parquet"
+    ]
+
+    valid_files = []
+    # Map filenames to their config keys
+    edge_map = {
+        "edges_trades.parquet": "trades",
+        "edges_lobbying.parquet": "lobbying",
+        "edges_camp_fin.parquet": "camp_fin",
+        "edges_geo.parquet": "geo"
+    }
+
+    for file in edge_files:
+        config_key = edge_map[file]
+        
+        # Check the toggle in CONFIG
+        if not CONFIG["INCLUDE_EDGES"].get(config_key, True):
+            print(f" -> Skipping '{config_key}' edge file per config.")
+            continue
+            
+        file_path = os.path.join(edge_dir, file)
+        if not os.path.exists(file_path):
+            print(f" -> [WARNING] Expected edge chunk not found: {file}")
+            continue
+            
+        valid_files.append(file_path)
+
+    files_sql = "[" + ", ".join([f"'{f}'" for f in valid_files]) + "]"
+
+    # 4.2 BUILD GLOBAL NODE ID DICTIONARIES
+    print(f"Extracting global distinct Node IDs for events >= {start_date}...")
+    out_dir = "data/processed/pyg_graph"
+    os.makedirs(out_dir, exist_ok=True)
+
+    # Use .df() for DuckDB to avoid the AttributeError
+    df_src = duckdb.query(f"""
+        SELECT DISTINCT src FROM read_parquet({files_sql}) 
+        WHERE src IS NOT NULL AND time >= '{start_date}'
+    """).df()
+    unique_src = df_src['src'].values
+    src_map = {val: i for i, val in enumerate(unique_src)}
+    
+    df_dst = duckdb.query(f"""
+        SELECT DISTINCT dst FROM read_parquet({files_sql}) 
+        WHERE dst IS NOT NULL AND time >= '{start_date}'
+    """).df()
+    unique_dst = df_dst['dst'].values
+    dst_start_idx = len(unique_src)
+    dst_map = {val: i + dst_start_idx for i, val in enumerate(unique_dst)}
+
+    # Save mapping for inference/analysis
+    np.save(os.path.join(out_dir, "src_id_map.npy"), src_map)
+    np.save(os.path.join(out_dir, "dst_id_map.npy"), dst_map)
+    print(f" -> Global mapping established: {len(src_map)} Politicians | {len(dst_map)} Companies")
+    
+    del df_src, df_dst
+    gc.collect()
+
+    # 4.3 DETERMINE ACTIVE YEARS
+    print("Identifying active years...")
+    years_df = duckdb.query(f"""
+        SELECT DISTINCT extract(year from time) as yr 
+        FROM read_parquet({files_sql}) 
+        WHERE time >= '{start_date}'
+        ORDER BY yr
+    """).df()
+    active_years = years_df['yr'].dropna().astype(int).tolist()
+    
+    saved_shards = []
+
+    # 4.4 GENERATE YEARLY SHARDS
+    for year in active_years:
+        print(f"\n--- Processing Shard: {year} ---")
+        
+        # Filter for the year, but respect the July 2012 start month for that specific year
+        query = f"""
+            SELECT * FROM read_parquet({files_sql})
+            WHERE extract(year from time) = {year}
+            AND time >= '{start_date}'
+            ORDER BY time ASC
+        """
+        
+        master_table = duckdb.query(query).arrow()
+        if hasattr(master_table, 'read_all'):
+            master_table = master_table.read_all()
+            
+        num_rows = master_table.num_rows
+        if num_rows == 0:
+            print(f" -> No valid events found for {year} after {start_date}. Skipping.")
+            continue
+            
+        print(f" -> Mapping {num_rows:,} events...")
+        df_ids = master_table.select(['src', 'dst']).to_pandas()
+        src_idx_array = df_ids['src'].map(src_map).values
+        dst_idx_array = df_ids['dst'].map(dst_map).values
+        del df_ids
+
+        # Base Tensors (Using long/int64 for standard PyG compatibility)
+        src_tensor = torch.from_numpy(src_idx_array).to(torch.long)
+        dst_tensor = torch.from_numpy(dst_idx_array).to(torch.long)
+        y_tensor = torch.from_numpy(master_table['y'].to_numpy()).to(torch.long)
+        event_type_tensor = torch.from_numpy(master_table['event_type'].to_numpy()).to(torch.long)
+        
+        time_array = master_table['time'].to_numpy().astype('datetime64[s]').astype(np.int64)
+        t_tensor = torch.from_numpy(time_array).to(torch.long)
+
+        # Message Attribute Tensor (D=24)
+        base_cols = ['src', 'dst', 'time', 'y', 'event_type']
+        msg_cols = [c for c in master_table.column_names if c not in base_cols]
+        
+        msg_tensor = torch.empty((num_rows, len(msg_cols)), dtype=torch.float)
+        for i, col in enumerate(msg_cols):
+            arr = master_table[col].combine_chunks().to_numpy(zero_copy_only=False)
+            msg_tensor[:, i] = torch.from_numpy(arr)
+            del arr 
+
+        # Assemble Object
+        data = TemporalData(
+            src=src_tensor,
+            dst=dst_tensor,
+            t=t_tensor,
+            msg=msg_tensor,
+            y=y_tensor
+        )
+        data.event_type = event_type_tensor
+        
+        # Audit
+        is_sorted = torch.all(t_tensor[1:] >= t_tensor[:-1]).item()
+        assert is_sorted, f"[{year}] Temporal leak detected: Events are not strictly chronological!"
+
+        # Save Shard
+        shard_path = os.path.join(out_dir, f"hillstreet_temporal_graph_{year}.pt")
+        torch.save(data, shard_path)
+        saved_shards.append(shard_path)
+        print(f" -> Shard saved successfully: {shard_path}")
+
+        # Memory Cleanup
+        del master_table, src_tensor, dst_tensor, y_tensor, event_type_tensor, t_tensor, msg_tensor, data
+        gc.collect()
+
+    print("\n==================================================")
+    print(f"PHASE 4 COMPLETE: Generated {len(saved_shards)} annual shards.")
+    print("==================================================\n")
+    
+    return saved_shards
+# ==========================================
+# MAIN ORCHESTRATION & CLI
+# ==========================================
+
+if __name__ == "__main__":
+    # 1. Setup Directories from CONFIG
+    EDGE_DIR = CONFIG["EDGE_OUT_DIR"]
+    os.makedirs(EDGE_DIR, exist_ok=True)
+    
+    # Check which edges are required based on the toggle panel
+    REQUIRED_EDGES = []
+    if CONFIG["INCLUDE_EDGES"].get("trades", True): REQUIRED_EDGES.append("edges_trades.parquet")
+    if CONFIG["INCLUDE_EDGES"].get("lobbying", True): REQUIRED_EDGES.append("edges_lobbying.parquet")
+    if CONFIG["INCLUDE_EDGES"].get("camp_fin", True): REQUIRED_EDGES.append("edges_camp_fin.parquet")
+    if CONFIG["INCLUDE_EDGES"].get("geo", True): REQUIRED_EDGES.append("edges_geo.parquet")
+    
+    # 2. Check for Phase 1 & 2 Persistence
+    phase2_done = all(os.path.exists(os.path.join(EDGE_DIR, f)) for f in REQUIRED_EDGES) and len(REQUIRED_EDGES) > 0
+    
+    if phase2_done:
+        print(f" -> Found existing edge parquets in {EDGE_DIR}. Skipping Phases 1 & 2.")
+        schema = pq.read_schema(os.path.join(EDGE_DIR, REQUIRED_EDGES[0]))
+        base_cols = ['src', 'dst', 'time', 'y', 'event_type']
+        all_msg_cols = [c for c in schema.names if c not in base_cols]
+    else:
+        df_trades, df_lobbying, df_camp_fin, df_geo, cw_2012, cw_2017, cw_cat = load_and_standardize_events()
+        EDGE_DIR, all_msg_cols = broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat)
+
+    # 3. Process Node Features
+    pol_feat_path, comp_feat_path = process_node_features()
+    
+    # 4. Generate Final PyG Dataset using the START_DATE from CONFIG
+    shards_generated = generate_hillstreet_dataset(
+        start_date=CONFIG["START_DATE"], 
+    )
+    
+    print(f"Successfully generated the following shards:\n{shards_generated}")