Upload 2 files

model_metadata.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0853f8b1a3286dbc3c4ca3da2f5a66c7922003a9f5b1d72036857de3c47188c6
+size 628246962

postprocess_jsonl_latest.py

@@ -0,0 +1,1626 @@
+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) ---
+import hashlib
+from multiformats import CID, multihash
+import tempfile
+import sys
+
+class ipfs_multiformats_py:
+    def __init__(self, resources=None, metadata=None):
+        self.multihash = multihash
+        # Added error handling for multihash version/import
+        if not hasattr(self.multihash, 'wrap') or not hasattr(self.multihash, 'decode'):
+             logging.warning("Multihash library structure might have changed. CID generation may fail.")
+        return None
+
+    def get_file_sha256(self, file_path):
+        hasher = hashlib.sha256()
+        try:
+            with open(file_path, 'rb') as f:
+                while chunk := f.read(8192):
+                    hasher.update(chunk)
+            return hasher.digest()
+        except Exception as e:
+            logging.error(f"Error hashing file {file_path}: {e}")
+            return None
+
+    # Takes bytes input directly
+    def get_bytes_sha256(self, data_bytes: bytes):
+        hasher = hashlib.sha256()
+        hasher.update(data_bytes)
+        return hasher.digest()
+
+    def get_multihash_sha256(self, content_hash):
+        if content_hash is None:
+            return None
+        try:
+            # Try using multihash.digest instead of wrap
+            mh = self.multihash.digest(content_hash, 'sha2-256')
+            return mh
+        except Exception as e:
+            logging.error(f"Error creating multihash: {e}")
+            return None
+
+    def get_multihash_sha256_old(self, content_hash):
+        if content_hash is None:
+            return None
+        try:
+            # Use 'sha2-256' which corresponds to code 0x12
+            #mh = self.multihash.wrap(code='sha2-256', digest=content_hash)
+            mh = self.multihash.wrap('sha2-256', content_hash)
+            return mh
+        except Exception as e:
+            logging.error(f"Error wrapping hash in multihash: {e}")
+            return None
+
+    def get_cid_old(self, data):
+        """Generates CID v1 base32 for bytes data or file path."""
+        mh = None
+        try:
+            if isinstance(data, (str, Path)) and os.path.isfile(data):
+                # logging.debug(f"Calculating CID for file: {data}")
+                file_content_hash = self.get_file_sha256(data)
+                mh = self.get_multihash_sha256(file_content_hash)
+            elif isinstance(data, bytes):
+                # logging.debug(f"Calculating CID for bytes (length: {len(data)})")
+                bytes_hash = self.get_bytes_sha256(data)
+                mh = self.get_multihash_sha256(bytes_hash)
+            elif isinstance(data, str):
+                # logging.debug(f"Calculating CID for string (length: {len(data)})")
+                # Treat string as UTF-8 bytes
+                bytes_hash = self.get_bytes_sha256(data.encode('utf-8'))
+                mh = self.get_multihash_sha256(bytes_hash)
+            else:
+                logging.warning(f"Unsupported data type for CID generation: {type(data)}. Skipping CID.")
+                return None
+
+            if mh:
+                # CIDv1, base32, raw codec (0x55)
+                cid = CID(base='base32', version=1, codec='raw', multihash=mh)
+                return str(cid)
+            else:
+                return None
+        except Exception as e:
+            logging.error(f"Error generating CID: {e}", exc_info=False)
+            return None
+
+    def get_cid(self, data):
+        """Generates CID v1 base32 for bytes data or file path."""
+        try:
+            # Get the hash first
+            content_hash = None
+            if isinstance(data, (str, Path)) and os.path.isfile(data):
+                content_hash = self.get_file_sha256(data)
+            elif isinstance(data, bytes):
+                content_hash = self.get_bytes_sha256(data)
+            elif isinstance(data, str):
+                content_hash = self.get_bytes_sha256(data.encode('utf-8'))
+            else:
+                logging.warning(f"Unsupported data type for CID generation: {type(data)}. Skipping CID.")
+                return None
+
+            if not content_hash:
+                return None
+
+            # Try the new CID API format
+            try:
+                # Version 1 of multiformats may use from_digest or other method instead of passing multihash directly
+                from multiformats import multihash
+                digest = multihash.digest(content_hash, 'sha2-256')
+                cid = CID.from_digest(digest, 'raw')  # Try this format first
+                return str(cid)
+            except (AttributeError, TypeError):
+                try:
+                    # Try alternate creation method
+                    mh = self.get_multihash_sha256(content_hash)
+                    cid = CID(version=1, codec='raw', hash=mh)  # Try with hash parameter
+                    return str(cid)
+                except:
+                    # Fallback to simple base64 encoding if CID creation fails
+                    import base64
+                    b64_hash = base64.b64encode(content_hash).decode('ascii')
+                    return f"sha256:{b64_hash}"
+
+        except Exception as e:
+            logging.error(f"Error generating CID: {e}", exc_info=False)
+            # Fallback to a simple hash representation
+            try:
+                if isinstance(data, (str, Path)) and os.path.isfile(data):
+                    content_hash = self.get_file_sha256(data)
+                elif isinstance(data, bytes):
+                    content_hash = self.get_bytes_sha256(data)
+                elif isinstance(data, str):
+                    content_hash = self.get_bytes_sha256(data.encode('utf-8'))
+                else:
+                    return None
+
+                import base64
+                return f"sha256:{base64.b64encode(content_hash).decode('ascii')}"
+            except:
+                return None
+# --- 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() # 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.")
+