Merge branch 'main' of https://huggingface.co/datasets/hfmlsoc/hub_weekly_snapshots

README.md

@@ -1,4 +1,61 @@
 ---
 license: odbl
 ---
-Weekly snapshots of Models, Datasets and Papers on the HF Hub
+Weekly snapshots of Models, Datasets and Papers on the HF Hub
+
+## Sample code
+
+To query the dataset to see which snapshots are observable, use e.g.:
+```python
+import json
+
+from datasets import load_dataset
+from huggingface_hub import HfApi
+
+REPO_ID = "hfmlsoc/hub_weekly_snapshots"
+
+hf_api = HfApi()
+all_files = hf_api.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
+
+repo_type_to_snapshots = {}
+for repo_fpath in all_files:
+    if ".parquet" in repo_fpath:
+        repo_type = repo_fpath.split("/")[0]
+        repo_type_to_snapshots[repo_type] = repo_type_to_snapshots.get(repo_type, []) + [repo_fpath]
+
+for repo_type in repo_type_to_snapshots:
+    repo_type_to_snapshots[repo_type] = sorted(repo_type_to_snapshots[repo_type], key=lambda x:x.split("/")[1])
+
+repo_type_to_snapshots
+```
+
+You can then load a specific snapshot as e.g.:
+```python
+date = "2025-01-01"
+snapshot = load_dataset(REPO_ID, data_files={date.replace("-",""): f"datasets/{date}/datasets.parquet"})
+snapshot
+```
+
+Returning:
+```
+DatasetDict({
+    20250101: Dataset({
+        features: ['_id', 'id', 'author', 'cardData', 'disabled', 'gated', 'lastModified', 'likes', 'trendingScore', 'private', 'sha', 'description', 'downloads', 'tags', 'createdAt', 'key', 'paperswithcode_id', 'citation'],
+        num_rows: 276421
+    })
+})
+```
+
+### Sample analysis of top datasets
+
+To look at the 10 most liked datasets as of January 1st 2025, you can then run:
+```python
+[{
+    "id": row['id'],
+    "tags": json.loads(row["cardData"]).get("tags", []),
+    "tasks": json.loads(row["cardData"]).get("task_categories", []),
+    "likes": row['likes'],
+} for row in snapshot["20250101"].sort("likes", reverse=True).select(range(10))]
+```
+
+Most of the user-maintained metadata for Hub repositories is stored in the cardData field, which is saved as a JSON-formated string

hub_download.py

@@ -2,59 +2,123 @@ import os
 import subprocess
 import datetime
 from pathlib import Path
-from git import Repo
+import shutil
 
 # --- CONFIGURATION ---
-REPO_URL="https://huggingface.co/datasets/cfahlgren1/hub-stats"
-FILE_PATH="<item>.parquet"
-DEST_DIR="weekly_snapshots/<item>"
-CLONE_DIR="temp_repo"
-# ----------------------
-
-# Clone repo if not already cloned
-if not os.path.exists(CLONE_DIR):
-    Repo.clone_from(REPO_URL, CLONE_DIR)
-
-repo = Repo(CLONE_DIR)
-assert not repo.bare
-
-# Get all commits that affected the file
-commits = list(repo.iter_commits(paths=FILE_PATH, reverse=True))
-
-if not commits:
-    print("No commits found for the file.")
-    exit()
-
-# Get the date of the first commit
-start_date = datetime.datetime.fromtimestamp(commits[0].committed_date).date()
-end_date = datetime.date.today()
-
-Path(DEST_DIR).mkdir(exist_ok=True)
-
-current_date = start_date
-week = datetime.timedelta(weeks=1)
-
-while current_date < end_date:
-    next_date = current_date + week
-
-    # Find latest commit before next_date that touches the file
-    weekly_commit = None
-    for commit in reversed(commits):
-        commit_date = datetime.datetime.fromtimestamp(commit.committed_date).date()
-        if current_date <= commit_date < next_date:
-            weekly_commit = commit
-            break
-
-    if weekly_commit:
-        try:
-            blob = weekly_commit.tree / FILE_PATH
-            weekly_folder = Path(DEST_DIR) / str(current_date)
-            weekly_folder.mkdir(parents=True, exist_ok=True)
-            output_path = weekly_folder / os.path.basename(FILE_PATH)
-            with open(output_path, 'wb') as f:
-                f.write(blob.data_stream.read())
-            print(f"Saved: {output_path}")
-        except KeyError:
-            print(f"File not found in commit {weekly_commit.hexsha}")
-
-    current_date = next_date
+
+items = ['spaces', 'models', 'datasets', 'daily_papers']
+REPO_URL = "https://huggingface.co/datasets/cfahlgren1/hub-stats"
+
+for item in items:
+    FILE_PATH = item+".parquet"
+    DEST_DIR = item
+    CLONE_DIR = "temp_repo"
+    # ----------------------
+
+    # First, make sure git lfs is installed on your system
+    try:
+        subprocess.run(["git", "lfs", "install"], check=True)
+        print("Git LFS installed successfully")
+    except Exception as e:
+        print(f"Warning: Git LFS installation might have failed: {e}")
+        print("Continuing anyway...")
+
+    # Clone repo if not already cloned
+    if not os.path.exists(CLONE_DIR):
+        print(f"Cloning repository with Git LFS: {REPO_URL}")
+        subprocess.run(["git", "lfs", "clone", REPO_URL, CLONE_DIR], check=True)
+    else:
+        print(f"Repository already exists at {CLONE_DIR}")
+        # Force checkout to main branch first before pulling
+        subprocess.run(["git", "-C", CLONE_DIR, "checkout", "main"], check=True)
+        subprocess.run(["git", "-C", CLONE_DIR, "pull"], check=True)
+
+    # Get all commits that affected the file
+    print(f"Finding commits for file: {FILE_PATH}")
+    git_log_cmd = ["git", "-C", CLONE_DIR, "log", "--pretty=format:%H|%ct", "--follow", FILE_PATH]
+    result = subprocess.run(git_log_cmd, capture_output=True, text=True, check=True)
+    commits_info = result.stdout.strip().split('\n')
+
+    if not commits_info or commits_info[0] == '':
+        print("No commits found for the file.")
+        exit()
+
+    # Parse commit info
+    commits = []
+    for commit_line in commits_info:
+        if '|' in commit_line:
+            hexsha, timestamp = commit_line.split('|')
+            commits.append((hexsha, int(timestamp)))
+
+    # Sort commits by timestamp (oldest first)
+    commits.sort(key=lambda x: x[1])
+
+    # Get the date of the first commit
+    start_date = datetime.datetime.fromtimestamp(commits[0][1]).date()
+    end_date = datetime.date.today()
+
+    Path(DEST_DIR).mkdir(parents=True, exist_ok=True)
+
+    current_date = start_date
+    week = datetime.timedelta(weeks=1)
+
+    print(f"Processing weekly snapshots from {start_date} to {end_date}")
+
+    while current_date < end_date:
+        next_date = current_date + week
+        next_date_timestamp = int(datetime.datetime.combine(next_date, datetime.time.min).timestamp())
+
+        # Find latest commit before next_date
+        weekly_commit = None
+        for hexsha, timestamp in reversed(commits):
+            if timestamp < next_date_timestamp:
+                weekly_commit = hexsha
+                commit_date = datetime.datetime.fromtimestamp(timestamp).date()
+                break
+
+        if weekly_commit:
+            try:
+                print(f"Processing week of {current_date} using commit {weekly_commit[:8]}")
+                
+                # Create the destination folder
+                weekly_folder = Path(DEST_DIR) / str(current_date)
+                weekly_folder.mkdir(parents=True, exist_ok=True)
+                output_path = weekly_folder / os.path.basename(FILE_PATH)
+                
+                # Checkout this specific commit
+                subprocess.run(["git", "-C", CLONE_DIR, "checkout", weekly_commit], check=True)
+                
+                # Force Git LFS to fetch the actual file content
+                subprocess.run(["git", "-C", CLONE_DIR, "lfs", "pull"], check=True)
+                
+                # Copy the actual file
+                source_file = os.path.join(CLONE_DIR, FILE_PATH)
+                
+                if os.path.exists(source_file):
+                    shutil.copy2(source_file, output_path)
+                    file_size = os.path.getsize(output_path) / (1024 * 1024)  # Size in MB
+                    print(f"Saved: {output_path} ({file_size:.2f} MB)")
+                    
+                    # Verify if it's actually a parquet file and not just a pointer
+                    with open(output_path, 'rb') as f:
+                        header = f.read(4)
+                    if header != b'PAR1':
+                        print(f"WARNING: File doesn't start with Parquet magic bytes. Size: {file_size:.2f} MB")
+                        if file_size < 1:  # Less than 1MB is suspicious for a Parquet file
+                            print("This is likely still an LFS pointer and not the actual file")
+                else:
+                    print(f"ERROR: Source file not found at {source_file}")
+                    
+            except Exception as e:
+                print(f"Error processing commit {weekly_commit}: {e}")
+        else:
+            print(f"No commit found for week of {current_date}")
+
+        current_date = next_date
+
+    # Return to main branch before exiting
+    try:
+        subprocess.run(["git", "-C", CLONE_DIR, "checkout", "main"], check=True)
+        print("Returned to main branch")
+    except Exception as e:
+        print(f"Warning: Couldn't return to main branch: {e}")