model_scraper.py

import os
import json
import logging
import time
from pathlib import Path
import shutil
import glob
from datetime import datetime
from huggingface_hub import list_models
from huggingface_hub.utils import HFValidationError

# --- Configuration --- (Same as before)
GDRIVE_MOUNT_POINT = "/content/drive/MyDrive"; GDRIVE_FOLDER_NAME = "hf_metadata_dataset_collection"; LOCAL_FOLDER_NAME = "hf_metadata_dataset_local_fallback"; LOCAL_WORK_DIR = Path("/content/hf_scraper_work"); LOCAL_TEMP_DATA_FILENAME = "temp_metadata_output.jsonl"; LOCAL_TEMP_LOG_FILENAME = "temp_metadata_scraper.log"; FINAL_MERGED_FILENAME = "all_models_metadata.jsonl"; FINAL_LOG_FILENAME = "metadata_scraper.log"; BACKUP_DATA_FILE_PREFIX = "metadata_backup_"; BACKUP_DATA_FILE_GLOB = f"{BACKUP_DATA_FILE_PREFIX}*.jsonl"; MAX_MODELS_TO_FETCH = None; FETCH_CARD_DATA = True; DELAY_BETWEEN_MODELS = 0.05; LOAD_RETRIES = 2; LOAD_RETRY_DELAY = 3; BACKUP_EVERY_N_RECORDS = 200

# --- Helper Functions ---
# (make_serializable, safe_serialize_dict, load_processed_ids, sync_local_to_drive
#  remain EXACTLY the same as the previous FULL version)
def make_serializable(obj):
    """Converts common non-serializable types found in ModelInfo."""
    if hasattr(obj, 'isoformat'): return obj.isoformat()
    if hasattr(obj, 'rfilename'): return obj.rfilename
    try: return str(obj)
    except Exception: return None

def safe_serialize_dict(data_dict):
    """Attempts to serialize a dictionary, handling non-serializable items."""
    serializable_dict = {}
    if not isinstance(data_dict, dict): logging.warning(f"safe_serialize_dict non-dict input: {type(data_dict)}"); return {}
    for key, value in data_dict.items():
        if isinstance(value, (list, tuple)): serializable_dict[key] = [make_serializable(item) for item in value]
        elif isinstance(value, dict): serializable_dict[key] = safe_serialize_dict(value)
        elif isinstance(value, (str, int, float, bool, type(None))): serializable_dict[key] = value
        else: serializable_dict[key] = make_serializable(value)
    return {k: v for k, v in serializable_dict.items() if v is not None or (k in data_dict and data_dict[k] is None)}


def load_processed_ids(main_filepath: Path, backup_dir: Path, backup_glob: str, retries: int = LOAD_RETRIES, delay: int = LOAD_RETRY_DELAY) -> set:
    """Reads the main JSON Lines file AND all backup files to get processed IDs."""
    processed_ids = set(); total_lines_read = 0; total_files_read = 0; files_to_read = []
    if main_filepath.is_file(): files_to_read.append(main_filepath); logging.info(f"Found main file: {main_filepath}")
    else: logging.info(f"Main file not found: {main_filepath}. Relying on backups.")
    backup_pattern = str(backup_dir / backup_glob); backup_files = sorted(glob.glob(backup_pattern))
    if backup_files: logging.info(f"Found {len(backup_files)} backup file(s)."); files_to_read.extend([Path(f) for f in backup_files])
    else: logging.info(f"No backup files found matching '{backup_pattern}'.")
    if not files_to_read: logging.info("No main/backup files found. Starting fresh."); return set()
    logging.info(f"Loading IDs from {len(files_to_read)} file(s)...")
    for filepath in files_to_read:
        logging.info(f"Reading: {filepath.name}"); file_lines_read = 0; skipped_lines = 0; loaded_from_this_file = 0; initial_set_size = len(processed_ids)
        for attempt in range(retries):
             try:
                with filepath.open('r', encoding='utf-8') as f:
                    for i, line in enumerate(f):
                        file_lines_read = i + 1; line = line.strip();
                        if not line: continue
                        try: data = json.loads(line)
                        except json.JSONDecodeError: skipped_lines += 1; continue
                        if 'id' in data and isinstance(data['id'], str): processed_ids.add(data['id'])
                        else: skipped_lines += 1
                    loaded_from_this_file = len(processed_ids) - initial_set_size; total_lines_read += file_lines_read; total_files_read += 1
                    logging.info(f"  -> Read {file_lines_read} lines, loaded {loaded_from_this_file} new IDs (skipped {skipped_lines}). Total IDs: {len(processed_ids)}"); break
             except FileNotFoundError: logging.warning(f"Attempt {attempt + 1}: File not found: {filepath}");
             except IOError as e: logging.error(f"IOError reading {filepath}: {e}. Skip file.", exc_info=True); break
             except Exception as e: logging.error(f"Error reading {filepath}: {e}. Skip file.", exc_info=True); break
             if attempt < retries - 1: time.sleep(delay);
             else: logging.error(f"Failed opening {filepath} after {retries} attempts. Skip file."); break
    logging.info(f"Finished loading. Total unique IDs: {len(processed_ids)} from {total_files_read} file(s).")
    return processed_ids

def sync_local_to_drive(local_data_path: Path, local_log_path: Path, final_backup_dir: Path, final_log_path: Path, backup_data_prefix: str):
    """Copies local temp data to backup on Drive. Copies local log to overwrite final log on Drive."""
    data_backup_success = False; log_copy_success = False
    # 1. Backup Data File
    if local_data_path.is_file() and local_data_path.stat().st_size > 0:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f"); backup_filename = f"{backup_data_prefix}{timestamp}.jsonl"; backup_filepath = final_backup_dir / backup_filename
        try:
            logging.info(f"Backing up '{local_data_path}' ({local_data_path.stat().st_size / 1024**2:.2f} MB) to '{backup_filepath}'...")
            final_backup_dir.mkdir(parents=True, exist_ok=True); shutil.copyfile(local_data_path, backup_filepath); logging.info(f"Data backup successful: '{backup_filepath}'."); data_backup_success = True
            try: logging.info(f"Clearing local temp data file '{local_data_path}'."); local_data_path.unlink()
            except Exception as e_unlink: logging.warning(f"Could not clear local temp data file after backup: {e_unlink}")
        except Exception as e_data: logging.error(f"CRITICAL: Failed to back up data '{local_data_path}' to '{backup_filepath}': {e_data}", exc_info=True); logging.warning("Local temp data file NOT cleared.")
    else: logging.debug("Local temp data empty/non-existent. Skip data backup."); data_backup_success = True
    # 2. Copy/Overwrite Log File
    if local_log_path.is_file() and local_log_path.stat().st_size > 0:
        try:
            logging.info(f"Copying local log '{local_log_path}' ({local_log_path.stat().st_size / 1024**2:.2f} MB) to overwrite '{final_log_path}'...")
            final_log_path.parent.mkdir(parents=True, exist_ok=True); shutil.copyfile(local_log_path, final_log_path); logging.info(f"Log file copy successful to '{final_log_path}'."); log_copy_success = True
        except Exception as e_log: logging.error(f"CRITICAL: Failed to copy log '{local_log_path}' to '{final_log_path}': {e_log}", exc_info=True)
    else: logging.debug("Local temp log empty/non-existent. Skip log copy."); log_copy_success = True
    return data_backup_success and log_copy_success


# --- Main Scraping Function ---
def scrape_all_hf_metadata(
    final_output_filepath: Path,
    final_backup_dir: Path,
    local_temp_data_path: Path,
    local_temp_log_path: Path,
    max_models=None,
    fetch_card_data=True,
    delay=0.05,
    backup_every=BACKUP_EVERY_N_RECORDS
    ):
    # --- Logging Setup (Points to LOCAL temp log path initially) ---
    log_file_handler = logging.FileHandler(local_temp_log_path)
    log_stream_handler = logging.StreamHandler()
    for handler in logging.root.handlers[:]: logging.root.removeHandler(handler)
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[log_file_handler, log_stream_handler])
    logging.getLogger('huggingface_hub.repocard_data').setLevel(logging.ERROR)
    final_log_filepath = final_backup_dir / FINAL_LOG_FILENAME # Define final log path

    # --- Start & Config Logging ---
    logging.info(f"--- Starting Aggregation Run ---")
    logging.info(f"Final backup/log directory: '{final_backup_dir}'")
    logging.info(f"Using local temp data file: '{local_temp_data_path}'")
    logging.info(f"Using local temp log file: '{local_temp_log_path}'")
    logging.info(f"Creating backup file every {backup_every} records.")
    # ... other config logs ...

    # --- Load processed IDs ---
    processed_ids = load_processed_ids(final_output_filepath, final_backup_dir, BACKUP_DATA_FILE_GLOB)
    initial_processed_count = len(processed_ids); logging.info(f"Resuming. {initial_processed_count} models previously processed.")

    # --- Initialize Counters & Fetch List ---
    models_processed_total_iterator = 0; models_saved_this_run_in_temp = 0; models_failed_serialization = 0; models_skipped_resume = 0;
    total_models_str = '?'; model_iterator = None; start_time = None; log_file_descriptor = -1;

    try:
        # Get log file descriptor
        try: log_file_descriptor = log_file_handler.stream.fileno()
        except Exception as log_fd_err: logging.warning(f"Could not get log file descriptor: {log_fd_err}")

        # --- Fetch Model List ---
        logging.info("Fetching model list...");
        try: model_iterator = list_models(limit=max_models, full=True, cardData=fetch_card_data, iterator=True); logging.info("Using iterator.")
        except TypeError as e:
             if 'iterator' in str(e): logging.warning("No iterator support. Falling back."); model_iterable_fallback = list_models(limit=max_models, full=True, cardData=fetch_card_data); model_iterator = model_iterable_fallback; logging.info("Fetched using fallback.")
             else: raise e
        if model_iterator is None: logging.error("Failed to get model list. Aborting."); return

        # --- Main Processing Loop ---
        start_time = time.time() # Start timer before the loop begins
        f_local_data = None     # Initialize file handle outside loop

        for model_info in model_iterator:
            # <<< Open/Reopen local temp file if needed >>>
            if f_local_data is None or f_local_data.closed:
                logging.info(f"Opening local temp data file '{local_temp_data_path}' for append ('a').")
                try:
                    f_local_data = local_temp_data_path.open('a', encoding='utf-8')
                    logging.info("Opened local temp data file successfully.")
                except IOError as e:
                    logging.error(f"CRITICAL IO error opening local temp data file '{local_temp_data_path}': {e}", exc_info=True)
                    break # Cannot continue without temp file

            # Process model
            models_processed_total_iterator += 1; model_id = model_info.id if hasattr(model_info, 'id') else 'UNKNOWN_ID'
            if model_id != 'UNKNOWN_ID' and model_id in processed_ids:
                models_skipped_resume += 1;
                if models_skipped_resume % 10000 == 1 : logging.info(f"Skipping '{model_id}' (processed). Total skipped: {models_skipped_resume}.")
                continue

            # Log Progress
            current_processed_count = models_processed_total_iterator - models_skipped_resume
            if current_processed_count % 250 == 1 and current_processed_count > 1:
                 if start_time: elapsed_time = time.time() - start_time; rate = (current_processed_count / elapsed_time) * 60 if elapsed_time > 0 else 0
                 logging.info(f"--- Progress: {current_processed_count} new (Iter: {models_processed_total_iterator}/{total_models_str}, Skip: {models_skipped_resume}) | In Temp: {models_saved_this_run_in_temp % backup_every} | Rate: {rate:.1f} new/min ---") # Show count *in current temp batch*

            # Process and Save to LOCAL TEMP
            try:
                # ... (Serialization logic - same as before) ...
                raw_metadata = model_info.__dict__; serializable_metadata = safe_serialize_dict(raw_metadata); json_record = json.dumps(serializable_metadata, ensure_ascii=False)

                f_local_data.write(json_record + '\n');
                models_saved_this_run_in_temp += 1 # Increment total count this run

                # <<< Periodic Backup/Sync (with close/reopen) >>>
                # Check using total count this run
                if models_saved_this_run_in_temp > 0 and models_saved_this_run_in_temp % backup_every == 0:
                    logging.info(f"Reached {backup_every} records in current batch ({models_saved_this_run_in_temp} total this run). Triggering backup/sync.");

                    # <<< Close local file BEFORE sync >>>
                    logging.debug("Closing local temp data file before sync...")
                    f_local_data.close()
                    logging.debug("Local temp data file closed.")

                    # Flush local log buffer
                    log_file_handler.flush()

                    # Perform the backup/sync
                    sync_successful = sync_local_to_drive(
                        local_temp_data_path,
                        local_temp_log_path,
                        final_backup_dir,
                        final_log_filepath,
                        BACKUP_DATA_FILE_PREFIX
                    )

                    if sync_successful:
                        logging.info(f"Periodic backup/sync successful. Local temp data file was cleared by sync function.")
                        # File handle `f_local_data` is already closed and file unlinked
                        # It will be reopened at the start of the next iteration
                    else:
                        logging.warning("Periodic backup/sync failed. Local temp files NOT cleared. Will retry next interval.")
                        # <<< Reopen local file immediately if sync failed to continue writing >>>
                        logging.info("Reopening local temp data file after failed sync...")
                        try:
                             f_local_data = local_temp_data_path.open('a', encoding='utf-8')
                             logging.info("Reopened local temp data file.")
                        except IOError as e_reopen:
                             logging.error(f"CRITICAL: Failed to reopen local temp file after failed sync: {e_reopen}. Aborting loop.", exc_info=True)
                             break # Exit loop if we can't reopen

                    # Optional: Sync log file descriptor if available
                    if log_file_descriptor != -1:
                         try: os.fsync(log_file_descriptor)
                         except Exception as log_sync_err: logging.error(f"Error syncing log file descriptor: {log_sync_err}")

            # Handle processing/write errors
            except Exception as e:
                models_failed_serialization += 1; logging.error(f"Processing/write local error for '{model_id}': {type(e).__name__}. Skip.", exc_info=False)

            # Delay
            if delay > 0: time.sleep(delay)
        # --- End For Loop ---

    # Handle interruptions/errors
    except KeyboardInterrupt: logging.warning("Scraping interrupted by user.")
    except Exception as e: logging.error(f"CRITICAL error during scraping: {e}", exc_info=True)

    finally:
        logging.info("--- Aggregation Summary (End of Run) ---")

        # <<< Close open file handle if loop exited >>>
        if f_local_data is not None and not f_local_data.closed:
            logging.info("Closing local temp data file handle before final sync.")
            f_local_data.close()

        # --- Final Backup/Sync ---
        logging.info("Attempting final backup/sync of local files...")
        final_sync_successful = sync_local_to_drive(
            local_temp_data_path,
            local_temp_log_path,
            final_backup_dir,
            final_log_filepath,
            BACKUP_DATA_FILE_PREFIX
        )
        # ... (rest of finally block and summary logging - same as before) ...
        if final_sync_successful: logging.info("Final backup/sync successful.")
        else: logging.warning("Final backup/sync FAILED.")
        final_total_count = initial_processed_count + models_saved_this_run_in_temp # Count based on temp file writes
        try: log_file_handler.flush(); # Only flush, fsync might fail if already closed
        except Exception as final_log_flush_e: logging.error(f"Error during final log flush: {final_log_flush_e}")
        if start_time:
             end_time = time.time(); total_time = end_time - start_time;
             logging.info(f"Total models encountered: {models_processed_total_iterator}"); logging.info(f"Models skipped (resume): {models_skipped_resume}"); logging.info(f"Models attempted this run: {models_processed_total_iterator - models_skipped_resume}");
             remaining_in_temp = local_temp_data_path.stat().st_size if local_temp_data_path.is_file() else 0
             logging.info(f"Records written locally this run: {models_saved_this_run_in_temp} ({remaining_in_temp} bytes left in temp if final sync failed)")
             logging.info(f"Total records saved to Drive (estimated): {final_total_count if final_sync_successful else initial_processed_count}") # More accurate estimate
             logging.info(f"Models skipped (errors): {models_failed_serialization}"); logging.info(f"Total time this run: {total_time:.2f} seconds");
        else: logging.info("Scraping did not reach main processing loop.")
        logging.info(f"Final Log file destination: '{final_log_filepath}'"); logging.info("--------------------------");
        log_file_handler.close();
        try:
             if local_temp_data_path.is_file(): local_temp_data_path.unlink(); logging.info(f"Cleaned up local temp data: {local_temp_data_path}")
             if local_temp_log_path.is_file(): local_temp_log_path.unlink(); logging.info(f"Cleaned up local temp log: {local_temp_log_path}")
        except Exception as clean_e: logging.warning(f"Could not clean up local temp files: {clean_e}")


# --- Script Execution (`if __name__ == "__main__":`) ---
if __name__ == "__main__":
    # --- Determine Output Paths ---
    print("--- Determining Output Paths ---")
    # ... (Path determination logic remains the same) ...
    gdrive_base = Path(GDRIVE_MOUNT_POINT); gdrive_target_dir = gdrive_base / GDRIVE_FOLDER_NAME; local_target_dir = Path(LOCAL_FOLDER_NAME); effective_final_dir = None;
    print(f"Checking for GDrive: {gdrive_base}");
    if gdrive_base.is_dir() and gdrive_base.exists():
        print(f"Mount OK. Checking target: {gdrive_target_dir}");
        if gdrive_target_dir.is_dir():
             print(f"Target Google Drive directory found. Using Google Drive.")
             effective_final_dir = gdrive_target_dir
        else:
             print(f"Target Google Drive directory '{gdrive_target_dir}' not found. Will attempt to create.")
             try:
                  gdrive_target_dir.mkdir(parents=True, exist_ok=True)
                  print(f"Successfully created Google Drive directory.")
                  effective_final_dir = gdrive_target_dir
             except Exception as e:
                  print(f"Error creating Google Drive directory '{gdrive_target_dir}': {e}")
                  print("Falling back to local directory.")
                  effective_final_dir = local_target_dir

    effective_final_dir.mkdir(parents=True, exist_ok=True); LOCAL_WORK_DIR.mkdir(parents=True, exist_ok=True); print(f"Effective final destination directory: {effective_final_dir}");
    final_output_filepath = effective_final_dir / FINAL_MERGED_FILENAME; final_log_filepath = effective_final_dir / FINAL_LOG_FILENAME; local_temp_data_path = LOCAL_WORK_DIR / LOCAL_TEMP_DATA_FILENAME; local_temp_log_path = LOCAL_WORK_DIR / LOCAL_TEMP_LOG_FILENAME;
    print(f"Main data file path (for loading IDs): {final_output_filepath}"); print(f"Backup data files pattern: {effective_final_dir / BACKUP_DATA_FILE_GLOB}"); print(f"Final log file path: {final_log_filepath}"); print(f"Local temp data file path: {local_temp_data_path}"); print(f"Local temp log file path: {local_temp_log_path}"); print("-" * 30);

    # Remove existing local temp files before start
    if local_temp_data_path.exists():
      print(f"Removing existing local temp data file: {local_temp_data_path}")
      try:
          local_temp_data_path.unlink()
      except OSError as e: print(f"Warning: Could not remove temp data file: {e}")

    if local_temp_log_path.exists():
      print(f"Removing existing local temp log file: {local_temp_log_path}")
      try:
          local_temp_log_path.unlink()
      except OSError as e: print(f"Warning: Could not remove temp log file: {e}")

    # --- Run the Scraper ---
    scrape_all_hf_metadata(
        final_output_filepath=final_output_filepath,
        final_backup_dir=effective_final_dir, # Corrected parameter name
        local_temp_data_path=local_temp_data_path,
        local_temp_log_path=local_temp_log_path,
        max_models=MAX_MODELS_TO_FETCH,
        fetch_card_data=FETCH_CARD_DATA,
        delay=DELAY_BETWEEN_MODELS,
        backup_every=BACKUP_EVERY_N_RECORDS
    )


# --- Optional: Post-Scraping Merge ---
print("\n--- Optional: Merging backup files ---")
backup_files_to_merge = sorted(glob.glob(str(effective_final_dir / BACKUP_DATA_FILE_GLOB)))
if backup_files_to_merge:
    print(f"Found {len(backup_files_to_merge)} backup files to merge into {final_output_filepath}")
    try:
      # Open the main file in append mode for merging
      with final_output_filepath.open('a', encoding='utf-8') as f_main:
          for backup_file in backup_files_to_merge:
              backup_path = Path(backup_file)
              print(f"Merging: {backup_path.name}...")
              # Open backup file in read mode
              with backup_path.open('r', encoding='utf-8') as f_backup:
                  shutil.copyfileobj(f_backup, f_main) # Efficiently copy content
                  # Delete the backup file after successful merge
                  backup_path.unlink()
                  print(f"Merged and deleted {backup_path.name}")
                  print("All backup files merged successfully.")
    except Exception as merge_e:
        print(f"Error during merge process: {merge_e}. Backup files were not deleted.")
else:
    print("No backup files found to merge.")