import os import json import logging import time import traceback from pathlib import Path import shutil import psutil import glob import gc from datetime import datetime from tqdm.auto import tqdm from typing import Optional, Union, Set, Dict, List, Tuple # Hugging Face related from huggingface_hub import list_models, hf_hub_download, HfApi from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError, HFValidationError # Data handling and Parquet import pandas as pd import pyarrow as pa import pyarrow.parquet as pq # Embeddings from sentence_transformers import SentenceTransformer import torch # --- IPFS CID Generation Code (from provided ipfs_multiformats.py) --- # https://github.com/endomorphosis/ipfs_accelerate_py/blob/5f88e36551b626e99b05bd4bd8a3e043c5c0e8c9/ipfs_accelerate_py/ipfs_multiformats.py#L25 import hashlib from multiformats import CID, multihash import tempfile import os import sys class ipfs_multiformats_py: def __init__(self, resources, metadata): self.multihash = multihash return None # Step 1: Hash the file content with SHA-256 def get_file_sha256(self, file_path): hasher = hashlib.sha256() with open(file_path, 'rb') as f: while chunk := f.read(8192): hasher.update(chunk) return hasher.digest() # Step 2: Wrap the hash in Multihash format def get_multihash_sha256(self, file_content_hash): mh = self.multihash.wrap(file_content_hash, 'sha2-256') return mh # Step 3: Generate CID from Multihash (CIDv1) def get_cid(self, file_data): if os.path.isfile(file_data) == True: absolute_path = os.path.abspath(file_data) file_content_hash = self.get_file_sha256(file_data) mh = self.get_multihash_sha256(file_content_hash) cid = CID('base32', 'raw', mh) else: with tempfile.NamedTemporaryFile(mode='w', delete=False) as f: filename = f.name with open(filename, 'w') as f_new: f_new.write(file_data) file_content_hash = self.get_file_sha256(filename) mh = self.get_multihash_sha256(file_content_hash) cid = CID('base32', 1, 'raw', mh) os.remove(filename) return str(cid) # --- End IPFS CID Code --- # --- Configuration --- # --- Paths --- 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(os.path.abspath("./hf_embedding_work")) # Input JSONL File INPUT_JSONL_FILENAME = "all_models_metadata.jsonl" # Assumed in final dir # --- Output File Names --- # Final Destination (Drive/Local Fallback) FINAL_METADATA_PARQUET_FILENAME = "model_metadata.parquet" # Metadata + CIDs FINAL_EMBEDDINGS_PARQUET_FILENAME = "model_embeddings.parquet" # CIDs + Embeddings FINAL_LOG_FILENAME = "embedding_generator.log" # Local Temporary Files (in LOCAL_WORK_DIR) LOCAL_TEMP_METADATA_JSONL = "temp_model_metadata.jsonl" LOCAL_TEMP_EMBEDDINGS_JSONL = "temp_model_embeddings.jsonl" LOCAL_TEMP_LOG_FILENAME = "temp_embedding_generator.log" # --- Batch Configuration --- BATCH_SAVE_THRESHOLD = 1000 # Save after processing this many records BATCH_SAVE_DIR_NAME = "batch_files" # Subdirectory for batch files PERIODIC_MERGE_FREQUENCY = 5 # Merge to Google Drive every X batches (0 to disable) CLEAN_AFTER_PERIODIC_MERGE = True # Whether to clean up batch files after periodic merge # --- Memory Management Configuration --- MEMORY_CLEANUP_THRESHOLD_MB = 1000 # Force extra cleanup if memory growth exceeds this # --- Processing Config --- MAX_RECORDS_TO_PROCESS = None # Limit records from JSONL (for testing), None for all BATCH_SIZE = 1024 EMBEDDING_MODEL_NAME = 'all-MiniLM-L6-v2' # Control what gets embedded and CID generated PROCESS_CONFIG_JSON = True PROCESS_README_CONTENT = True # --- Hub Upload Config --- UPLOAD_TO_HUB = True TARGET_REPO_ID = "YourUsername/your-dataset-repo-name" # CHANGE THIS TARGET_REPO_TYPE = "dataset" METADATA_FILENAME_IN_REPO = "model_metadata.parquet" EMBEDDINGS_FILENAME_IN_REPO = "model_embeddings.parquet" # --- Setup Logging --- logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') # --- Helper Functions --- 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.""" # This function might not be needed if we read directly from JSONL, # but keep it for potential future use or if handling raw ModelInfo objects. 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)} # --- NEW: Generate Record CID Function --- def generate_record_cid(cid_generator, model_id: str, config_cid: Optional[str] = None, readme_cid: Optional[str] = None) -> str: """ Generate a primary record CID from model_id and available content CIDs. This will be used as the primary key for both Parquet files. """ # Create a base string that combines all available IDs cid_parts = [f"model:{model_id}"] if config_cid: cid_parts.append(f"config:{config_cid}") if readme_cid: cid_parts.append(f"readme:{readme_cid}") # Join all parts and generate a CID from the combined string combined_string = "|".join(cid_parts) return cid_generator.get_cid(combined_string) # --- Safe Parquet Saving Function --- def save_dataframe_to_parquet_safely(df, filepath): """Saves DataFrame to Parquet with explicit schema handling for mixed types.""" try: # First attempt: Convert known problematic columns to string df_safe = df.copy() # Handle the 'gated' column specifically which caused the original error if 'gated' in df_safe.columns: df_safe['gated'] = df_safe['gated'].astype(str) # Convert all object columns except model_id and record_cid to string to be safe for col in df_safe.select_dtypes(include=['object']).columns: if col not in ['model_id', 'record_cid', 'config_cid', 'readme_cid']: # Keep IDs as is df_safe[col] = df_safe[col].astype(str) # Try saving with pandas df_safe.to_parquet(filepath, index=False, compression='gzip') return True except Exception as e: logging.warning(f"First attempt to save Parquet failed: {e}") try: # Second attempt: Use PyArrow with explicit schema schema = pa.Schema.from_pandas(df) fields = list(schema) # Convert all string/binary fields to string type except IDs for i, field in enumerate(fields): if (pa.types.is_string(field.type) or pa.types.is_binary(field.type)) and \ field.name not in ['model_id', 'record_cid', 'config_cid', 'readme_cid']: fields[i] = pa.field(field.name, pa.string()) new_schema = pa.schema(fields) # Force conversion of problematic columns df_safe = df.copy() for col in df_safe.select_dtypes(include=['object']).columns: if col not in ['model_id', 'record_cid', 'config_cid', 'readme_cid']: df_safe[col] = df_safe[col].astype(str) # Convert to table with schema and write table = pa.Table.from_pandas(df_safe, schema=new_schema) pq.write_table(table, filepath) logging.info(f"Successfully saved to {filepath} using PyArrow with schema conversion") return True except Exception as e2: logging.error(f"Both Parquet saving attempts failed for {filepath}: {e2}") # Last resort - save to CSV instead try: csv_filepath = filepath.with_suffix('.csv') logging.warning(f"Falling back to CSV format: {csv_filepath}") df.to_csv(csv_filepath, index=False) logging.info(f"Saved as CSV instead: {csv_filepath}") return False except Exception as e3: logging.error(f"Even CSV fallback failed: {e3}") return False # --- UPDATED: Load Processed CIDs from EMBEDDINGS Parquet and Batch Files --- def load_processed_cids_from_parquet(filepath: Path, batch_dir: Optional[Path] = None) -> set: """ Reads the record_cid column from: 1. The final EMBEDDINGS Parquet file 2. Any batch files in the batch_dir, if provided 3. Also checks for CSV fallback files Returns a set of processed record_cids. """ processed_cids = set() # 1. Load from final Parquet if it exists if filepath.is_file(): logging.info(f"Found existing EMBEDDINGS Parquet: {filepath}. Loading processed CIDs...") try: # Only load the record_cid column for efficiency df_existing = pd.read_parquet(filepath, columns=['record_cid']) file_cids = set(df_existing['record_cid'].tolist()) processed_cids.update(file_cids) logging.info(f"Loaded {len(file_cids)} CIDs from existing Embeddings Parquet.") except Exception as e: logging.warning(f"Could not load 'record_cid' from '{filepath}': {e}. Will check for CSV fallback.") # Check for CSV fallback csv_filepath = filepath.with_suffix('.csv') if csv_filepath.is_file(): try: df_csv = pd.read_csv(csv_filepath, usecols=['record_cid']) csv_cids = set(df_csv['record_cid'].tolist()) processed_cids.update(csv_cids) logging.info(f"Loaded {len(csv_cids)} CIDs from CSV fallback: {csv_filepath}") except Exception as csv_e: logging.warning(f"Could not load CIDs from CSV fallback: {csv_e}") # 2. Load from batch files if provided if batch_dir and batch_dir.is_dir(): # Check both Parquet and CSV batch files batch_files_parquet = list(batch_dir.glob("embeddings_batch_*.parquet")) batch_files_csv = list(batch_dir.glob("embeddings_batch_*.csv")) if batch_files_parquet: logging.info(f"Found {len(batch_files_parquet)} embedding batch Parquet files.") batch_cids_count = 0 for batch_file in batch_files_parquet: try: df_batch = pd.read_parquet(batch_file, columns=['record_cid']) batch_cids = set(df_batch['record_cid'].tolist()) batch_cids_count += len(batch_cids) processed_cids.update(batch_cids) except Exception as e: logging.warning(f"Error loading CIDs from batch file {batch_file}: {e}") logging.info(f"Loaded {batch_cids_count} additional CIDs from Parquet batch files.") if batch_files_csv: logging.info(f"Found {len(batch_files_csv)} embedding batch CSV files.") csv_batch_cids_count = 0 for batch_file in batch_files_csv: try: df_batch = pd.read_csv(batch_file, usecols=['record_cid']) batch_cids = set(df_batch['record_cid'].tolist()) csv_batch_cids_count += len(batch_cids) processed_cids.update(batch_cids) except Exception as e: logging.warning(f"Error loading CIDs from CSV batch file {batch_file}: {e}") logging.info(f"Loaded {csv_batch_cids_count} additional CIDs from CSV batch files.") total_cids = len(processed_cids) if total_cids > 0: logging.info(f"Total of {total_cids} unique record CIDs loaded for resume.") else: logging.info(f"No existing processed CIDs found. Will process all records.") return processed_cids # final conversion from JSONL to Parquet would happen only once at the end of all processing. def convert_jsonl_to_parquet( meta_jsonl_path: Path, embed_jsonl_path: Path, local_temp_metadata_path: Path, local_temp_embeddings_path: Path, chunk_size: int = 50000, max_memory_mb: int = 2000 # Memory threshold for adaptive processing ): """ Convert very large JSONL files to Parquet using a streaming approach with minimal memory usage. Args: meta_jsonl_path: Path to metadata JSONL file embed_jsonl_path: Path to embeddings JSONL file local_temp_metadata_path: Output path for metadata Parquet file local_temp_embeddings_path: Output path for embeddings Parquet file chunk_size: Initial number of records to process at once (will adapt based on memory usage) max_memory_mb: Maximum memory usage threshold in MB """ import json import os import gc import time import pyarrow as pa import pyarrow.parquet as pq from tqdm import tqdm import psutil logging.info("Starting optimized streaming conversion from JSONL to Parquet") def get_memory_usage_mb(): """Get current memory usage in MB""" process = psutil.Process(os.getpid()) return process.memory_info().rss / (1024 * 1024) def estimate_total_lines(file_path, sample_size=1000000): """Estimate total lines in file without reading entire file""" try: # Get file size file_size = os.path.getsize(file_path) # If file is small enough, just count lines directly if file_size < 100 * 1024 * 1024: # 100 MB with open(file_path, 'r') as f: return sum(1 for _ in f) # Sample beginning of file to estimate line size line_count = 0 bytes_read = 0 with open(file_path, 'r') as f: for _ in range(sample_size): line = f.readline() if not line: break bytes_read += len(line.encode('utf-8')) line_count += 1 if line_count == 0: return 0 # Calculate average line size and estimate total avg_line_size = bytes_read / line_count estimated_lines = int(file_size / avg_line_size) logging.info(f"Estimated lines in {file_path.name}: {estimated_lines:,} (based on avg line size: {avg_line_size:.1f} bytes)") return estimated_lines except Exception as e: logging.error(f"Error estimating lines in file: {e}") return 0 def infer_schema_from_samples(file_path, num_samples=1000): """Infer schema by sampling from beginning, middle, and end of file""" try: file_size = os.path.getsize(file_path) if file_size == 0: return None samples = [] with open(file_path, 'r') as f: # Read samples from beginning for _ in range(num_samples // 3): line = f.readline() if not line: break try: samples.append(json.loads(line)) except json.JSONDecodeError: continue # Read samples from middle middle_pos = file_size // 2 f.seek(middle_pos) f.readline() # Skip partial line for _ in range(num_samples // 3): line = f.readline() if not line: break try: samples.append(json.loads(line)) except json.JSONDecodeError: continue # Read samples from end end_pos = max(0, file_size - 100000) # 100 KB from end f.seek(end_pos) f.readline() # Skip partial line for _ in range(num_samples // 3): line = f.readline() if not line: break try: samples.append(json.loads(line)) except json.JSONDecodeError: continue if not samples: logging.error(f"No valid JSON samples found in {file_path}") return None # Convert samples to pyarrow schema import pandas as pd sample_df = pd.DataFrame(samples) # Convert all columns to string type to avoid type mismatches for col in sample_df.columns: if col != 'embedding': # Keep embedding as is since it's numeric sample_df[col] = sample_df[col].astype(str) # Handle embedding field specially if it exists if 'embedding' in sample_df.columns: # Ensure embedding is a list of float if sample_df['embedding'].dtype != 'object': # If not already a list, convert to string sample_df['embedding'] = sample_df['embedding'].astype(str) # Convert to PyArrow Table and extract schema table = pa.Table.from_pandas(sample_df) logging.info(f"Inferred schema with {len(table.schema.names)} fields") return table.schema except Exception as e: logging.error(f"Error inferring schema: {e}", exc_info=True) return None def stream_jsonl_to_parquet(jsonl_path, parquet_path, file_type, initial_chunk_size): """Process a JSONL file in a streaming fashion with adaptive chunk sizing""" if not jsonl_path.exists(): logging.warning(f"{file_type} JSONL file not found: {jsonl_path}") return False logging.info(f"Starting streaming conversion of {file_type} JSONL: {jsonl_path} -> {parquet_path}") start_time = time.time() # Get schema by sampling schema = infer_schema_from_samples(jsonl_path) if schema is None: logging.error(f"Failed to infer schema for {file_type}") return False # Estimate total for progress reporting estimated_total = estimate_total_lines(jsonl_path) # Track current chunk size - will adapt based on memory usage current_chunk_size = initial_chunk_size records_processed = 0 chunk_count = 0 try: # Create parquet writer with inferred schema with pq.ParquetWriter(parquet_path, schema) as writer: # Process in chunks to limit memory usage buffer = [] with tqdm(total=estimated_total, desc=f"Converting {file_type}") as pbar: with open(jsonl_path, 'r') as f: for line_num, line in enumerate(f, 1): try: record = json.loads(line) # Convert all string fields to ensure type consistency for key, value in record.items(): if key != 'embedding' and value is not None and not isinstance(value, (list, dict)): record[key] = str(value) buffer.append(record) # When buffer reaches chunk size, write to parquet if len(buffer) >= current_chunk_size: # Convert buffer to PyArrow table import pandas as pd chunk_df = pd.DataFrame(buffer) # Handle embedding field specially if it exists if 'embedding' in chunk_df.columns: # Ensure embedding is a list of float if chunk_df['embedding'].dtype != 'object': # If not already a list, convert to string chunk_df['embedding'] = chunk_df['embedding'].astype(str) # Convert non-embedding fields to string for col in chunk_df.columns: if col != 'embedding': chunk_df[col] = chunk_df[col].astype(str) # Write chunk table = pa.Table.from_pandas(chunk_df, schema=schema) writer.write_table(table) # Update progress records_processed += len(buffer) pbar.update(len(buffer)) chunk_count += 1 # Clear buffer and force garbage collection buffer = [] del chunk_df, table gc.collect() # Adaptive chunk sizing based on memory usage current_memory = get_memory_usage_mb() if current_memory > max_memory_mb: # Reduce chunk size if memory usage is too high new_chunk_size = max(1000, int(current_chunk_size * 0.8)) logging.info(f"Memory usage high ({current_memory:.1f} MB). Reducing chunk size from {current_chunk_size} to {new_chunk_size}") current_chunk_size = new_chunk_size elif current_memory < max_memory_mb * 0.5 and current_chunk_size < initial_chunk_size: # Increase chunk size if memory usage is low new_chunk_size = min(initial_chunk_size, int(current_chunk_size * 1.2)) logging.info(f"Memory usage low ({current_memory:.1f} MB). Increasing chunk size from {current_chunk_size} to {new_chunk_size}") current_chunk_size = new_chunk_size # Log progress periodically if chunk_count % 10 == 0: elapsed = time.time() - start_time rate = records_processed / elapsed if elapsed > 0 else 0 logging.info(f"Processed {records_processed:,} records ({rate:.1f} records/sec), memory: {current_memory:.1f} MB") except json.JSONDecodeError: logging.warning(f"Invalid JSON at line {line_num}") continue except Exception as e: logging.warning(f"Error processing line {line_num}: {e}") continue # Write any remaining records if buffer: try: import pandas as pd chunk_df = pd.DataFrame(buffer) # Handle embedding field specially if it exists if 'embedding' in chunk_df.columns: # Ensure embedding is a list of float if chunk_df['embedding'].dtype != 'object': # If not already a list, convert to string chunk_df['embedding'] = chunk_df['embedding'].astype(str) # Convert non-embedding fields to string for col in chunk_df.columns: if col != 'embedding': chunk_df[col] = chunk_df[col].astype(str) # Write final chunk table = pa.Table.from_pandas(chunk_df, schema=schema) writer.write_table(table) # Update progress records_processed += len(buffer) pbar.update(len(buffer)) except Exception as e: logging.error(f"Error writing final chunk: {e}") # Report final stats elapsed = time.time() - start_time rate = records_processed / elapsed if elapsed > 0 else 0 logging.info(f"Successfully converted {records_processed:,} {file_type} records in {elapsed:.1f} seconds ({rate:.1f} records/sec)") logging.info(f"Created {file_type} Parquet file: {parquet_path} ({os.path.getsize(parquet_path) / (1024*1024):.1f} MB)") return True except Exception as e: logging.error(f"Error during {file_type} conversion: {e}", exc_info=True) return False # Convert metadata file meta_success = stream_jsonl_to_parquet(meta_jsonl_path, local_temp_metadata_path, "metadata", chunk_size) # Force garbage collection before processing embeddings gc.collect() # Convert embeddings file embed_success = stream_jsonl_to_parquet(embed_jsonl_path, local_temp_embeddings_path, "embeddings", chunk_size) if meta_success and embed_success: logging.info("JSONL to Parquet conversion completed successfully") return True else: logging.error("JSONL to Parquet conversion encountered errors") return False # --- Sync Local Files to Final Destination --- def sync_local_files_to_final( local_metadata_path: Path, local_embeddings_path: Path, local_log_path: Path, final_metadata_path: Path, final_embeddings_path: Path, final_log_path: Path ): """ Copies local Parquet/log files to overwrite final destination files. Returns True if all necessary copies succeeded. """ success = True # Assume success initially # Copy Metadata Parquet or CSV if local_metadata_path.is_file(): try: logging.info(f"Copying local Metadata '{local_metadata_path}' to '{final_metadata_path}'...") final_metadata_path.parent.mkdir(parents=True, exist_ok=True) shutil.copyfile(local_metadata_path, final_metadata_path) logging.info("Metadata file copy successful.") except Exception as e: logging.error(f"Failed to copy Metadata file: {e}", exc_info=True) success = False # Also check for CSV fallback csv_path = local_metadata_path.with_suffix('.csv') if csv_path.is_file(): try: csv_dest = final_metadata_path.with_suffix('.csv') logging.info(f"Copying CSV fallback: {csv_path} to {csv_dest}") shutil.copyfile(csv_path, csv_dest) except Exception as e: logging.error(f"Failed to copy CSV fallback: {e}") # Don't affect overall success status for CSV fallback else: logging.debug("Local Metadata file non-existent. Skipping copy.") # Copy Embeddings Parquet or CSV if local_embeddings_path.is_file(): try: logging.info(f"Copying local Embeddings '{local_embeddings_path}' to '{final_embeddings_path}'...") final_embeddings_path.parent.mkdir(parents=True, exist_ok=True) shutil.copyfile(local_embeddings_path, final_embeddings_path) logging.info("Embeddings file copy successful.") except Exception as e: logging.error(f"Failed to copy Embeddings file: {e}", exc_info=True) success = False # Also check for CSV fallback csv_path = local_embeddings_path.with_suffix('.csv') if csv_path.is_file(): try: csv_dest = final_embeddings_path.with_suffix('.csv') logging.info(f"Copying CSV fallback: {csv_path} to {csv_dest}") shutil.copyfile(csv_path, csv_dest) except Exception as e: logging.error(f"Failed to copy CSV fallback: {e}") # Don't affect overall success status for CSV fallback else: logging.debug("Local Embeddings file non-existent. Skipping copy.") # Copy 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}' 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("Log file copy successful.") except Exception as e: logging.error(f"Failed to copy log file: {e}", exc_info=True) success = False # Log copy fail is less critical but still indicate else: logging.debug("Local temp log empty/non-existent. Skipping log copy.") return success # Track memory across perform_periodic_merge() function calls last_merge_memory_usage = 0 def perform_periodic_merge( batch_save_dir: Path, merged_batch_tracker: Set[str], local_temp_metadata_path: Path, local_temp_embeddings_path: Path, final_log_path: Path, local_temp_log_path: Path ): """ 100% JSONL-only periodic merge with NO Parquet operations whatsoever. Only merges to JSONL files, conversion to Parquet happens separately at the end. """ global last_merge_memory_usage # Track memory at function start process = psutil.Process() start_memory = process.memory_info().rss / (1024 * 1024) logging.info(f"Starting JSONL-only periodic merge. Current memory: {start_memory:.2f} MB") # Define paths for working JSONL files (strip .parquet suffix if present) meta_jsonl_path = Path(str(local_temp_metadata_path).replace('.parquet', '.jsonl')) embed_jsonl_path = Path(str(local_temp_embeddings_path).replace('.parquet', '.jsonl')) # Find all JSONL batch files that haven't been merged yet meta_batch_files = [] embed_batch_files = [] # Only look for JSONL batch files for batch_file in batch_save_dir.glob("metadata_batch_*.jsonl"): if batch_file.name not in merged_batch_tracker: meta_batch_files.append(batch_file) for batch_file in batch_save_dir.glob("embeddings_batch_*.jsonl"): if batch_file.name not in merged_batch_tracker: embed_batch_files.append(batch_file) if not meta_batch_files and not embed_batch_files: logging.info("No new JSONL batches to merge periodically.") return 0 logging.info(f"Performing JSONL-only merge of {len(meta_batch_files)} metadata files and {len(embed_batch_files)} embedding files") # --- Process metadata files --- if meta_batch_files: try: # Load existing record CIDs from JSONL to avoid duplicates existing_cids = set() # Check if JSONL exists from previous run and load CIDs if meta_jsonl_path.exists(): logging.info(f"Scanning existing JSONL for CIDs: {meta_jsonl_path}") with open(meta_jsonl_path, 'r') as f: for line in f: try: record = json.loads(line) if 'record_cid' in record: existing_cids.add(record['record_cid']) except: pass logging.info(f"Found {len(existing_cids)} existing CIDs in metadata JSONL") # Open JSONL in append mode with open(meta_jsonl_path, 'a') as jsonl_out: # Process each batch file for batch_file in meta_batch_files: try: logging.info(f"Processing metadata batch: {batch_file.name}") # Process the JSONL batch file line by line new_records_count = 0 total_records_count = 0 with open(batch_file, 'r') as batch_in: for line in batch_in: total_records_count += 1 try: record = json.loads(line) # Filter out records with CIDs that already exist if 'record_cid' in record and record['record_cid'] not in existing_cids: # Write new record to output JSONL jsonl_out.write(line) # Add to existing CIDs to avoid future duplicates existing_cids.add(record['record_cid']) new_records_count += 1 except json.JSONDecodeError: logging.warning(f"Could not parse JSON line in {batch_file.name}") # Log stats logging.info(f"Batch has {total_records_count} records, {new_records_count} are new") # Mark batch as processed merged_batch_tracker.add(batch_file.name) # Clean up batch file if enabled if CLEAN_AFTER_PERIODIC_MERGE: try: batch_file.unlink() logging.debug(f"Removed processed batch file: {batch_file}") except Exception as e: logging.warning(f"Could not remove batch file: {e}") # Force memory cleanup after each batch gc.collect() except Exception as e: logging.error(f"Error processing batch file {batch_file}: {e}") except Exception as e: logging.error(f"Error in metadata merge process: {e}", exc_info=True) # Force memory cleanup between metadata and embeddings gc.collect() # --- Process embeddings files (similar approach) --- if embed_batch_files: try: # Load existing record CIDs from JSONL to avoid duplicates existing_cids = set() # Check if JSONL exists from previous run and load CIDs if embed_jsonl_path.exists(): logging.info(f"Scanning existing JSONL for CIDs: {embed_jsonl_path}") with open(embed_jsonl_path, 'r') as f: for line in f: try: record = json.loads(line) if 'record_cid' in record: existing_cids.add(record['record_cid']) except: pass logging.info(f"Found {len(existing_cids)} existing CIDs in embeddings JSONL") # Open JSONL in append mode with open(embed_jsonl_path, 'a') as jsonl_out: # Process each batch file for batch_file in embed_batch_files: try: logging.info(f"Processing embeddings batch: {batch_file.name}") # Process the JSONL batch file line by line new_records_count = 0 total_records_count = 0 with open(batch_file, 'r') as batch_in: for line in batch_in: total_records_count += 1 try: record = json.loads(line) # Filter out records with CIDs that already exist if 'record_cid' in record and record['record_cid'] not in existing_cids: # Write new record to output JSONL jsonl_out.write(line) # Add to existing CIDs to avoid future duplicates existing_cids.add(record['record_cid']) new_records_count += 1 except json.JSONDecodeError: logging.warning(f"Could not parse JSON line in {batch_file.name}") # Log stats logging.info(f"Batch has {total_records_count} records, {new_records_count} are new") # Mark batch as processed merged_batch_tracker.add(batch_file.name) # Clean up batch file if enabled if CLEAN_AFTER_PERIODIC_MERGE: try: batch_file.unlink() logging.debug(f"Removed processed batch file: {batch_file}") except Exception as e: logging.warning(f"Could not remove batch file: {e}") # Force memory cleanup after each batch gc.collect() except Exception as e: logging.error(f"Error processing batch file {batch_file}: {e}") except Exception as e: logging.error(f"Error in embeddings merge process: {e}", exc_info=True) # -- Only sync the log file, no Parquet files during runtime -- try: if local_temp_log_path.is_file() and local_temp_log_path.stat().st_size > 0: final_log_path.parent.mkdir(parents=True, exist_ok=True) shutil.copyfile(local_temp_log_path, final_log_path) logging.info("Log file sync successful.") except Exception as e: logging.error(f"Failed to sync log file: {e}") # Final cleanup for _ in range(3): gc.collect() # Update memory tracking for next call end_memory = process.memory_info().rss / (1024 * 1024) logging.info(f"Memory at end of merge: {end_memory:.2f} MB (Change: {end_memory - start_memory:.2f} MB)") last_merge_memory_usage = end_memory return len(meta_batch_files) + len(embed_batch_files) # --- UPDATED: Main Embedding Generation Function with CID-based Primary Key --- def create_embedding_dataset( input_jsonl_filepath: Path, final_metadata_parquet_path: Path, final_embeddings_parquet_path: Path, local_temp_metadata_path: Path, local_temp_embeddings_path: Path, local_temp_log_path: Path, final_log_filepath: Path, max_records: Optional[int] = None, batch_size: int = 32, embedding_model_name: str = EMBEDDING_MODEL_NAME, process_config: bool = PROCESS_CONFIG_JSON, process_readme: bool = PROCESS_README_CONTENT, ): """ JSONL-only workflow that reads metadata, generates CIDs & embeddings, and saves all outputs as JSONL until the very end. """ # --- Setup batch directory --- batch_save_dir = LOCAL_WORK_DIR / BATCH_SAVE_DIR_NAME batch_save_dir.mkdir(parents=True, exist_ok=True) # --- Define JSONL paths by converting Parquet paths --- meta_jsonl_path = Path(str(local_temp_metadata_path).replace('.parquet', '.jsonl')) embed_jsonl_path = Path(str(local_temp_embeddings_path).replace('.parquet', '.jsonl')) # --- Configure logging to use the local temp log file --- 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) # --- Log configuration --- logging.info(f"--- Starting Embedding Generation with JSONL-only workflow ---") logging.info(f"Input JSONL: '{input_jsonl_filepath}'") logging.info(f"Metadata JSONL Output: '{meta_jsonl_path}'") logging.info(f"Embeddings JSONL Output: '{embed_jsonl_path}'") logging.info(f"Final Metadata Parquet Output (post-processing): '{final_metadata_parquet_path}'") logging.info(f"Final Embeddings Parquet Output (post-processing): '{final_embeddings_parquet_path}'") logging.info(f"Batch Save Directory: '{batch_save_dir}'") logging.info(f"Batch Save Threshold: {BATCH_SAVE_THRESHOLD}") logging.info(f"Periodic Merge Frequency: {PERIODIC_MERGE_FREQUENCY} batches") logging.info(f"Clean After Periodic Merge: {CLEAN_AFTER_PERIODIC_MERGE}") logging.info(f"Local Temp Log: '{local_temp_log_path}'") logging.info(f"Final Log Output: '{final_log_filepath}'") logging.info(f"Embedding Model: '{embedding_model_name}', Batch Size: {batch_size}") logging.info(f"Process Config: {process_config}, Process README: {process_readme}") logging.info(f"Max Records: {'All' if max_records is None else max_records}") # --- Load Embedding Model --- try: logging.info(f"Loading embedding model: {embedding_model_name}") # Check for MPS (Apple Silicon GPU) availability first, then CUDA, then fall back to CPU if hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): device = 'mps' logging.info(f"Using Apple Silicon GPU (MPS)") elif torch.cuda.is_available(): device = 'cuda' logging.info(f"Using NVIDIA GPU (CUDA)") else: device = 'cpu' logging.info(f"Using CPU (no GPU acceleration available)") model = SentenceTransformer(embedding_model_name, device=device) cid_generator = ipfs_multiformats_py(resources=None, metadata=None) # Initialize CID generator logging.info("Embedding model & CID generator loaded.") except Exception as e: logging.error(f"Failed to load embedding model or init CID generator: {e}", exc_info=True) return None, None # Return None for both paths # --- Load processed CIDs from existing JSONL files --- processed_cids = set() # 1. Check the main embeddings JSONL file if embed_jsonl_path.exists(): logging.info(f"Found existing embeddings JSONL: {embed_jsonl_path}. Loading processed CIDs...") try: with open(embed_jsonl_path, 'r') as f: for line in f: try: record = json.loads(line) if 'record_cid' in record: processed_cids.add(record['record_cid']) except: pass logging.info(f"Loaded {len(processed_cids)} CIDs from existing embeddings JSONL.") except Exception as e: logging.warning(f"Could not load CIDs from '{embed_jsonl_path}': {e}") # 2. Check batch files batch_files = list(batch_save_dir.glob("embeddings_batch_*.jsonl")) if batch_files: logging.info(f"Found {len(batch_files)} embedding batch JSONL files.") batch_cids_count = 0 for batch_file in batch_files: try: with open(batch_file, 'r') as f: for line in f: try: record = json.loads(line) if 'record_cid' in record: processed_cids.add(record['record_cid']) batch_cids_count += 1 except: pass except Exception as e: logging.warning(f"Error loading CIDs from batch file {batch_file}: {e}") logging.info(f"Loaded {batch_cids_count} additional CIDs from JSONL batch files.") initial_processed_count = len(processed_cids) logging.info(f"Resuming from {initial_processed_count} records already processed.") # --- Batch saving and periodic merge setup --- batch_counter = 0 records_since_last_save = 0 merged_batch_tracker = set() # Track which batch files have been merged # Keep a lookup of model_id to record_cid for this session model_id_to_record_cid = {} # --- Process JSONL File --- metadata_records_list = [] # Holds dicts for metadata embeddings_records_list = [] # Holds dicts for embeddings batch_inputs = [] # Holds tuples for batch processing record_count_from_jsonl = 0; processed_count_this_run = 0; skipped_resume_count = 0; skipped_error_count = 0 start_time = None try: logging.info(f"Opening input JSONL file: {input_jsonl_filepath}") start_time = time.time() with input_jsonl_filepath.open('r', encoding='utf-8') as f_jsonl: pbar = tqdm(f_jsonl, desc="Processing JSONL", unit="record") for line in pbar: record_count_from_jsonl += 1 if max_records is not None and processed_count_this_run >= max_records: logging.info(f"Reached max_records limit ({max_records}). Stopping."); break try: line = line.strip() if not line: continue data = json.loads(line) # Original metadata dictionary model_id = data.get('id') if not model_id or not isinstance(model_id, str): logging.warning(f"Skip record {record_count_from_jsonl}: missing/invalid 'id'."); skipped_error_count += 1; continue # --- Extract text for embedding & CID generation --- config_text = ""; config_cid = None; config_dict_or_str = data.get('config') if process_config and config_dict_or_str is not None: if isinstance(config_dict_or_str, dict): try: config_text = json.dumps(config_dict_or_str, separators=(',', ':')); config_cid = cid_generator.get_cid(config_text) # Use compact string for CID except TypeError: logging.warning(f"Cannot serialize config for {model_id}. Skip CID/embed.") elif isinstance(config_dict_or_str, str): # Handle if config is already a string config_text = config_dict_or_str; config_cid = cid_generator.get_cid(config_text) else: logging.warning(f"Config for {model_id} type {type(config_dict_or_str)}. Skip CID/embed.") readme_text = ""; readme_cid = None if process_readme: card_data = data.get('cardData') if isinstance(card_data, dict): readme_text = card_data.get('text', '') or '' elif isinstance(card_data, str): readme_text = card_data # If cardData itself is the string if not readme_text and isinstance(data.get('description'), str): readme_text = data['description'] # Fallback if readme_text: readme_cid = cid_generator.get_cid(readme_text) # --- Generate record_cid (primary key) --- record_cid = generate_record_cid(cid_generator, model_id, config_cid, readme_cid) # Store in lookup for future reference model_id_to_record_cid[model_id] = record_cid # Skip if this record_cid has already been processed if record_cid in processed_cids: skipped_resume_count += 1 continue processed_count_this_run += 1 pbar.set_postfix_str(f"Batching: {model_id}", refresh=True) # Add to batch for embedding batch_inputs.append((data, config_text, readme_text, config_cid, readme_cid, record_cid)) # --- Process Batch when full --- if len(batch_inputs) >= batch_size: pbar.set_postfix_str(f"Embedding batch ({len(batch_inputs)})...", refresh=True) try: original_data_batch = [item[0] for item in batch_inputs] config_texts_batch = [item[1] for item in batch_inputs] readme_texts_batch = [item[2] for item in batch_inputs] config_cids_batch = [item[3] for item in batch_inputs] readme_cids_batch = [item[4] for item in batch_inputs] record_cids_batch = [item[5] for item in batch_inputs] # Generate embeddings config_embeddings = model.encode(config_texts_batch, batch_size=batch_size, show_progress_bar=False) if process_config else [None] * len(batch_inputs) readme_embeddings = model.encode(readme_texts_batch, batch_size=batch_size, show_progress_bar=False) if process_readme else [None] * len(batch_inputs) # --- Create records for BOTH data formats --- for i, original_data in enumerate(original_data_batch): current_model_id = original_data.get('id') current_record_cid = record_cids_batch[i] if not current_model_id or not current_record_cid: continue # 1. Metadata Record metadata_record = original_data.copy() # Start with all original metadata # Remove bulky/embedded fields if they exist, keep CIDs metadata_record.pop('config_embedding', None) metadata_record.pop('readme_embedding', None) # Add CIDs metadata_record['record_cid'] = current_record_cid # Primary key if process_config: metadata_record['config_cid'] = config_cids_batch[i] if process_readme: metadata_record['readme_cid'] = readme_cids_batch[i] metadata_records_list.append(metadata_record) # 2. Embedding Record embedding_record = { 'record_cid': current_record_cid, # Primary key 'model_id': current_model_id # Keep model_id for reference } if process_config: embedding_record['config_embedding'] = config_embeddings[i].tolist() if config_texts_batch[i] else None if process_readme: embedding_record['readme_embedding'] = readme_embeddings[i].tolist() if readme_texts_batch[i] else None embeddings_records_list.append(embedding_record) # Mark this record as processed to avoid reprocessing if script restarts processed_cids.add(current_record_cid) # Increment counter for batch saving records_since_last_save += 1 logging.debug(f"Processed batch. Metadata size: {len(metadata_records_list)}, Embeddings size: {len(embeddings_records_list)}") # --- Save batch if we've reached the threshold --- if records_since_last_save >= BATCH_SAVE_THRESHOLD: batch_counter += 1 timestamp = int(time.time()) # Save metadata batch as JSONL meta_batch_file = batch_save_dir / f"metadata_batch_{batch_counter}_{timestamp}.jsonl" success_meta = True try: with open(meta_batch_file, 'w') as f: for record in metadata_records_list: f.write(json.dumps(safe_serialize_dict(record)) + '\n') logging.info(f"Saved metadata batch {batch_counter} as JSONL with {len(metadata_records_list)} records") except Exception as e: logging.error(f"Error saving metadata batch as JSONL: {e}") success_meta = False # Save embeddings batch as JSONL embed_batch_file = batch_save_dir / f"embeddings_batch_{batch_counter}_{timestamp}.jsonl" success_embed = True try: with open(embed_batch_file, 'w') as f: for record in embeddings_records_list: f.write(json.dumps(safe_serialize_dict(record)) + '\n') logging.info(f"Saved embeddings batch {batch_counter} as JSONL with {len(embeddings_records_list)} records") except Exception as e: logging.error(f"Error saving embeddings batch as JSONL: {e}") success_embed = False if success_meta and success_embed: logging.info(f"Saved batch {batch_counter} with {len(embeddings_records_list)} records") else: logging.warning(f"Batch {batch_counter} save had issues. Check logs.") # Clear the lists to start a new batch and reset counter metadata_records_list = [] embeddings_records_list = [] records_since_last_save = 0 # --- Periodic merge to final JSONL files --- if PERIODIC_MERGE_FREQUENCY > 0 and batch_counter % PERIODIC_MERGE_FREQUENCY == 0: pbar.set_postfix_str(f"Periodic merge to JSONL...", refresh=True) batches_merged = perform_periodic_merge( batch_save_dir=batch_save_dir, merged_batch_tracker=merged_batch_tracker, local_temp_metadata_path=local_temp_metadata_path, local_temp_embeddings_path=local_temp_embeddings_path, final_log_path=final_log_filepath, local_temp_log_path=local_temp_log_path ) pbar.set_postfix_str(f"Merged {batches_merged} batches to JSONL", refresh=True) except Exception as e_embed: logging.error(f"Error embedding batch: {e_embed}", exc_info=True) skipped_error_count += len(batch_inputs) # Count whole batch as skipped batch_inputs = [] # Clear batch # Handle line processing errors except json.JSONDecodeError: logging.warning(f"Skip record {record_count_from_jsonl}: JSON decode error."); skipped_error_count += 1 except Exception as e_line: logging.error(f"Skip record {record_count_from_jsonl}: Error - {e_line}", exc_info=False); skipped_error_count += 1 # --- End reading JSONL file --- # --- Process Final Remaining Batch --- if batch_inputs: pbar.set_postfix_str(f"Embedding final batch ({len(batch_inputs)})...", refresh=True) try: # Process just like the main batch original_data_batch = [item[0] for item in batch_inputs] config_texts_batch = [item[1] for item in batch_inputs] readme_texts_batch = [item[2] for item in batch_inputs] config_cids_batch = [item[3] for item in batch_inputs] readme_cids_batch = [item[4] for item in batch_inputs] record_cids_batch = [item[5] for item in batch_inputs] config_embeddings = model.encode(config_texts_batch, batch_size=batch_size, show_progress_bar=False) if process_config else [None] * len(batch_inputs) readme_embeddings = model.encode(readme_texts_batch, batch_size=batch_size, show_progress_bar=False) if process_readme else [None] * len(batch_inputs) for i, original_data in enumerate(original_data_batch): current_model_id = original_data.get('id') current_record_cid = record_cids_batch[i] if not current_model_id or not current_record_cid: continue metadata_record = original_data.copy() metadata_record.pop('config_embedding', None) metadata_record.pop('readme_embedding', None) metadata_record['record_cid'] = current_record_cid # Primary key if process_config: metadata_record['config_cid'] = config_cids_batch[i] if process_readme: metadata_record['readme_cid'] = readme_cids_batch[i] metadata_records_list.append(metadata_record) embedding_record = { 'record_cid': current_record_cid, # Primary key 'model_id': current_model_id # Keep model_id for reference } if process_config: embedding_record['config_embedding'] = config_embeddings[i].tolist() if config_texts_batch[i] else None if process_readme: embedding_record['readme_embedding'] = readme_embeddings[i].tolist() if readme_texts_batch[i] else None embeddings_records_list.append(embedding_record) # Mark as processed processed_cids.add(current_record_cid) records_since_last_save += 1 logging.debug(f"Processed final batch. Metadata size: {len(metadata_records_list)}, Embeddings size: {len(embeddings_records_list)}") except Exception as e_embed_final: logging.error(f"Error embedding final batch: {e_embed_final}", exc_info=True) skipped_error_count += len(batch_inputs) # --- End processing batches --- # --- Save any remaining records as a final batch --- if metadata_records_list: batch_counter += 1 timestamp = int(time.time()) # Save final metadata batch as JSONL meta_batch_file = batch_save_dir / f"metadata_batch_{batch_counter}_{timestamp}.jsonl" success_meta = True try: with open(meta_batch_file, 'w') as f: for record in metadata_records_list: f.write(json.dumps(safe_serialize_dict(record)) + '\n') logging.info(f"Saved final metadata batch as JSONL with {len(metadata_records_list)} records") except Exception as e: logging.error(f"Error saving final metadata batch as JSONL: {e}") success_meta = False # Save final embeddings batch as JSONL embed_batch_file = batch_save_dir / f"embeddings_batch_{batch_counter}_{timestamp}.jsonl" success_embed = True try: with open(embed_batch_file, 'w') as f: for record in embeddings_records_list: f.write(json.dumps(safe_serialize_dict(record)) + '\n') logging.info(f"Saved final embeddings batch as JSONL with {len(embeddings_records_list)} records") except Exception as e: logging.error(f"Error saving final embeddings batch as JSONL: {e}") success_embed = False if success_meta and success_embed: logging.info(f"Saved final batch {batch_counter} with {len(embeddings_records_list)} records") else: logging.warning(f"Final batch {batch_counter} save had issues. Check logs.") # Clear lists metadata_records_list = [] embeddings_records_list = [] pbar.close() logging.info("Finished processing records from JSONL.") # --- Merge all remaining batches into the final JSONL files --- # Process any remaining batches that haven't been merged if PERIODIC_MERGE_FREQUENCY > 0: logging.info("Performing final merge of any remaining batches...") batches_merged = perform_periodic_merge( batch_save_dir=batch_save_dir, merged_batch_tracker=merged_batch_tracker, local_temp_metadata_path=local_temp_metadata_path, local_temp_embeddings_path=local_temp_embeddings_path, final_log_path=final_log_filepath, local_temp_log_path=local_temp_log_path ) logging.info(f"Final merge: processed {batches_merged} remaining batches") # Return the JSONL paths for final conversion return meta_jsonl_path, embed_jsonl_path # Handle file/main processing errors except FileNotFoundError: logging.error(f"CRITICAL: Input JSONL file not found: {input_jsonl_filepath}."); return None, None except Exception as e_main: logging.error(f"CRITICAL error: {e_main}", exc_info=True); return None, None # --- Final Summary --- finally: total_processed_in_run = processed_count_this_run total_batches_saved = batch_counter total_batches_merged = len(merged_batch_tracker) logging.info("--- Embedding Generation Summary ---") logging.info(f"Records read from JSONL: {record_count_from_jsonl}") logging.info(f"Records skipped (resume): {skipped_resume_count}") logging.info(f"Records processed this run: {total_processed_in_run}") logging.info(f"Records skipped (errors): {skipped_error_count}") logging.info(f"Total batches saved: {total_batches_saved}") logging.info(f"Total batches merged: {total_batches_merged}") logging.info(f"Total unique records processed (including previous runs): {len(processed_cids)}") if start_time: logging.info(f"Total processing time: {time.time() - start_time:.2f} seconds") logging.info("------------------------------------") # --- Upload Function (Modified for two files) --- def upload_files_to_hub( local_metadata_path: Path, local_embeddings_path: Path, repo_id: str, repo_type: str = "dataset", metadata_path_in_repo: Optional[str] = None, embeddings_path_in_repo: Optional[str] = None, hf_token: Union[str, bool, None] = None ): """Uploads the generated Parquet files to the Hugging Face Hub.""" api = HfApi(token=hf_token) uploaded_meta = False uploaded_embed = False # Upload Metadata (Parquet or CSV) if local_metadata_path and local_metadata_path.exists(): path_in_repo_meta = metadata_path_in_repo or local_metadata_path.name logging.info(f"Uploading Metadata: {local_metadata_path} to {repo_id} as {path_in_repo_meta}...") try: api.upload_file( path_or_fileobj=str(local_metadata_path), path_in_repo=path_in_repo_meta, repo_id=repo_id, repo_type=repo_type, commit_message=f"Update metadata ({local_metadata_path.suffix}) {time.strftime('%Y-%m-%d %H:%M:%S')}" ); logging.info("Metadata upload successful."); uploaded_meta = True except Exception as e: logging.error(f"Metadata upload failed: {e}", exc_info=True) else: logging.warning("Local metadata file not found or not specified. Skipping metadata upload.") # Upload Embeddings (Parquet or CSV) if local_embeddings_path and local_embeddings_path.exists(): path_in_repo_embed = embeddings_path_in_repo or local_embeddings_path.name logging.info(f"Uploading Embeddings: {local_embeddings_path} to {repo_id} as {path_in_repo_embed}...") try: api.upload_file( path_or_fileobj=str(local_embeddings_path), path_in_repo=path_in_repo_embed, repo_id=repo_id, repo_type=repo_type, commit_message=f"Update embeddings ({local_embeddings_path.suffix}) {time.strftime('%Y-%m-%d %H:%M:%S')}" ); logging.info("Embeddings upload successful."); uploaded_embed = True except Exception as e: logging.error(f"Embeddings upload failed: {e}", exc_info=True) else: logging.warning("Local embeddings file not found or not specified. Skipping embeddings upload.") return uploaded_meta and uploaded_embed # Return overall success # --- Script Execution (`if __name__ == "__main__":`) --- if __name__ == "__main__": # --- Determine Paths --- print("--- Determining Output Paths ---") gdrive_base = Path(GDRIVE_MOUNT_POINT); gdrive_target_dir = gdrive_base / GDRIVE_FOLDER_NAME local_fallback_dir = Path(LOCAL_FOLDER_NAME); effective_final_dir = None; print(f"Checking 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 else: local_fallback_dir.mkdir(parents=True, exist_ok=True) print(f"Mount not found. Using local fallback: {local_fallback_dir}") effective_final_dir = local_fallback_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}"); # Define final destination paths final_metadata_filepath = effective_final_dir / FINAL_METADATA_PARQUET_FILENAME final_embeddings_filepath = effective_final_dir / FINAL_EMBEDDINGS_PARQUET_FILENAME final_log_filepath = effective_final_dir / FINAL_LOG_FILENAME input_jsonl_filepath = effective_final_dir / INPUT_JSONL_FILENAME # Assume input is also in final dir # Define local working paths local_temp_metadata_path = LOCAL_WORK_DIR / LOCAL_TEMP_METADATA_JSONL local_temp_embeddings_path = LOCAL_WORK_DIR / LOCAL_TEMP_EMBEDDINGS_JSONL local_temp_log_path = LOCAL_WORK_DIR / LOCAL_TEMP_LOG_FILENAME print(f"Input JSONL path: {input_jsonl_filepath}") print(f"Final Metadata Parquet path: {final_metadata_filepath}") print(f"Final Embeddings Parquet path: {final_embeddings_filepath}") print(f"Final log file path: {final_log_filepath}") print(f"Local temp Metadata path: {local_temp_metadata_path}") print(f"Local temp Embeddings path: {local_temp_embeddings_path}") print(f"Local temp log file path: {local_temp_log_path}") print("-" * 30) # Check for existing local temp files (for resumption) resuming_from_previous_run = False if local_temp_metadata_path.exists() and local_temp_embeddings_path.exists(): file_size_meta = local_temp_metadata_path.stat().st_size file_size_embed = local_temp_embeddings_path.stat().st_size if file_size_meta > 0 and file_size_embed > 0: print(f"Found existing temp files, will resume processing:") print(f" - Metadata file: {local_temp_metadata_path} ({file_size_meta} bytes)") print(f" - Embeddings file: {local_temp_embeddings_path} ({file_size_embed} bytes)") resuming_from_previous_run = True else: print(f"Found existing temp files but they're empty, removing them:") if file_size_meta == 0: print(f" - Removing empty metadata file: {local_temp_metadata_path}") local_temp_metadata_path.unlink() if file_size_embed == 0: print(f" - Removing empty embeddings file: {local_temp_embeddings_path}") local_temp_embeddings_path.unlink() else: print(f"No existing temp files found, starting fresh processing run.") # --- Run the Embedding Generation --- # Returns paths to the *local* temp parquet files if successful local_meta_path, local_embed_path = create_embedding_dataset( input_jsonl_filepath=input_jsonl_filepath, final_metadata_parquet_path=final_metadata_filepath, # For loading resume final_embeddings_parquet_path=final_embeddings_filepath, # For loading resume local_temp_metadata_path=local_temp_metadata_path, # Local save dest local_temp_embeddings_path=local_temp_embeddings_path, # Local save dest local_temp_log_path=local_temp_log_path, # Local log dest final_log_filepath=final_log_filepath, # Final log for logging clarity max_records=MAX_RECORDS_TO_PROCESS, batch_size=BATCH_SIZE, embedding_model_name=EMBEDDING_MODEL_NAME, process_config=PROCESS_CONFIG_JSON, process_readme=PROCESS_README_CONTENT, ) # --- Sync final local files to Drive/Destination --- if local_meta_path or local_embed_path: # Check if at least one file was created logging.info("Attempting to sync final local files to destination...") # After all processing is complete meta_jsonl_path = LOCAL_WORK_DIR / LOCAL_TEMP_METADATA_JSONL embed_jsonl_path = LOCAL_WORK_DIR / LOCAL_TEMP_EMBEDDINGS_JSONL # After all processing is complete # Define Parquet output paths local_temp_metadata_parquet = LOCAL_WORK_DIR / FINAL_METADATA_PARQUET_FILENAME local_temp_embeddings_parquet = LOCAL_WORK_DIR / FINAL_EMBEDDINGS_PARQUET_FILENAME # One-time conversion from JSONL to Parquet at the very end convert_jsonl_to_parquet( meta_jsonl_path=meta_jsonl_path, embed_jsonl_path=embed_jsonl_path, local_temp_metadata_path=local_temp_metadata_parquet, local_temp_embeddings_path=local_temp_embeddings_parquet, chunk_size=50000, # Starting chunk size (will adapt) max_memory_mb=2000 # Memory threshold in MB ) sync_success = sync_local_files_to_final( local_metadata_path=local_temp_metadata_parquet, # Use the defined local path vars local_embeddings_path=local_temp_embeddings_path, local_log_path=local_temp_log_path, final_metadata_path=final_metadata_filepath, final_embeddings_path=final_embeddings_filepath, final_log_path=final_log_filepath ) if sync_success: logging.info("Final sync to destination successful.") # --- Upload final Parquet from Destination to Hub (Optional) --- if UPLOAD_TO_HUB: upload_files_to_hub( local_metadata_path=final_metadata_filepath, # Upload from final dest local_embeddings_path=final_embeddings_filepath, repo_id=TARGET_REPO_ID, repo_type=TARGET_REPO_TYPE, metadata_path_in_repo=METADATA_FILENAME_IN_REPO, embeddings_path_in_repo=EMBEDDINGS_FILENAME_IN_REPO, hf_token=None # Uses login ) else: logging.info("Hub upload skipped by configuration.") else: logging.error("Final sync to destination FAILED. Cannot upload to Hub.") else: logging.warning("Local Parquet file creation failed or no data processed. Skipping final sync and Hub upload.") ''' # --- Clean up local temp files --- logging.info("Attempting final cleanup of local temp files...") try: if local_temp_metadata_path.is_file(): local_temp_metadata_path.unlink(); logging.info(f"Cleaned {local_temp_metadata_path}") if local_temp_embeddings_path.is_file(): local_temp_embeddings_path.unlink(); logging.info(f"Cleaned {local_temp_embeddings_path}") if local_temp_log_path.is_file(): local_temp_log_path.unlink(); logging.info(f"Cleaned {local_temp_log_path}") except Exception as clean_e: logging.warning(f"Could not clean up local temp files: {clean_e}") ''' logging.info("Script finished.")