Update: read from raw split, push to deduplicated split

deduplicate_clients.py

@@ -18,7 +18,14 @@ It also strips " (via mcp-remote X.Y.Z)" suffixes from client names and reports
 the mcp-remote versions encountered.
 
 Usage:
-    uv run deduplicate_clients.py [--source-repo REPO] [--target-repo REPO]
+    # Push deduplicated data to the same repo (evalstate/mcp-clients) under 'deduplicated' split
+    uv run deduplicate_clients.py --push-to-hub
+
+    # Read from raw, push to dedup split in same repo
+    uv run deduplicate_clients.py --source-split raw --target-split deduplicated --push-to-hub
+
+    # Output to local file
+    uv run deduplicate_clients.py -o deduplicated.ndjson
 """
 
 import sys
@@ -62,16 +69,97 @@ def normalize_capabilities(caps):
     return caps
 
 
+def capabilities_to_string(caps):
+    """Convert capabilities to JSON string for storage."""
+    if caps is None:
+        return ''
+    if isinstance(caps, dict):
+        return json.dumps(caps, sort_keys=True)
+    return str(caps)
+
+
+def create_dataset_from_deduplicated(deduplicated_list, features=None):
+    """Create a Hugging Face Dataset from the deduplicated list."""
+    if features is None:
+        features = Features({
+            'name': Value('string'),
+            'versions': Value('string'),
+            'capabilities': Value('string'),
+            'last_seen': Value('string'),
+        })
+
+    records = []
+    for client in deduplicated_list:
+        records.append({
+            'name': client['name'],
+            'versions': client['versions'],
+            'capabilities': capabilities_to_string(client['capabilities']),
+            'last_seen': client['last_seen'],
+        })
+
+    return Dataset.from_list(records, features=features)
+
+
+def push_to_hub(deduplicated_list, repo_id, split=None, token=None, private=False):
+    """Push the deduplicated dataset to Hugging Face Hub."""
+    dataset = create_dataset_from_deduplicated(deduplicated_list)
+
+    if split:
+        print(f"Pushing dataset to https://huggingface.co/datasets/{repo_id} (split: {split})", file=sys.stderr)
+    else:
+        print(f"Pushing dataset to https://huggingface.co/datasets/{repo_id}", file=sys.stderr)
+
+    dataset.push_to_hub(
+        repo_id=repo_id,
+        split=split,
+        token=token,
+        private=private,
+        commit_message=f"Update deduplicated clients ({datetime.now().strftime('%Y-%m-%d %H:%M')})",
+    )
+
+    print(f"Successfully pushed {len(deduplicated_list):,} deduplicated records to {repo_id}", file=sys.stderr)
+
+
 def main():
-    parser = argparse.ArgumentParser(description="Deduplicate MCP clients by name and capabilities")
-    parser.add_argument("--source-repo", default="evalstate/mcp-clients", help="Source repository ID")
-    parser.add_argument("--target-repo", default="evalstate/mcp-clients-dedup", help="Target repository ID")
+    parser = argparse.ArgumentParser(
+        description="Deduplicate MCP clients by name and capabilities",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Push deduplicated data to same repo under 'deduplicated' split
+  %(prog)s --push-to-hub
+
+  # Use custom source/target splits
+  %(prog)s --source-split raw --target-split dedup --push-to-hub
+
+  # Output to local file
+  %(prog)s -o deduplicated.ndjson
+
+  # Push to a different repo
+  %(prog)s --target-repo my-org/mcp-clients-dedup --push-to-hub
+        """
+    )
+    parser.add_argument("-o", "--output", help="Output file path (default: stdout)")
+    parser.add_argument("--source-repo", default="evalstate/mcp-clients",
+                        help="Source repository ID (default: evalstate/mcp-clients)")
+    parser.add_argument("--source-split", default="raw",
+                        help="Source split name (default: raw)")
+    parser.add_argument("--target-repo", default="evalstate/mcp-clients",
+                        help="Target repository ID (default: evalstate/mcp-clients)")
+    parser.add_argument("--target-split", default="deduplicated",
+                        help="Target split name (default: deduplicated)")
+    parser.add_argument("--push-to-hub", action="store_true",
+                        help="Push the resulting dataset to Hugging Face Hub")
+    parser.add_argument("--token", default=None,
+                        help="HF token (defaults to HF_TOKEN env var or cached token)")
+    parser.add_argument("--private", action="store_true",
+                        help="Create/push to a private repository")
     args = parser.parse_args()
 
-    print(f"[{datetime.now().isoformat()}] Loading dataset from {args.source_repo}...", file=sys.stderr)
+    print(f"[{datetime.now().isoformat()}] Loading dataset from {args.source_repo} ({args.source_split} split)...", file=sys.stderr)
 
-    # Load the source dataset
-    ds = load_dataset(args.source_repo, split='train')
+    # Load the source dataset from the specified split
+    ds = load_dataset(args.source_repo, split=args.source_split)
 
     print(f"[{datetime.now().isoformat()}] Loaded {len(ds):,} client records", file=sys.stderr)
 
@@ -89,21 +177,14 @@ def main():
             mcp_remote_versions[mcp_version] += 1
 
         # Normalize capabilities for grouping
-        caps = row['capabilities']
-        if isinstance(caps, str):
-            try:
-                caps_dict = json.loads(caps)
-                caps_key = json.dumps(caps_dict, sort_keys=True)
-            except Exception:
-                caps_key = caps
-        else:
-            caps_key = json.dumps(caps, sort_keys=True) if caps else ''
+        caps = normalize_capabilities(row['capabilities'])
+        caps_key = capabilities_to_string(caps)
 
         key = (clean_name, caps_key)
         groups[key].append({
             'name': clean_name,
             'version': row['version'],
-            'capabilities': caps_key,
+            'capabilities': caps,
             'last_seen': row['last_seen'],
         })
 
@@ -134,7 +215,7 @@ def main():
         deduplicated.append({
             'name': name,
             'versions': versions_str,
-            'capabilities': caps_key,
+            'capabilities': latest_record['capabilities'],
             'last_seen': latest_record['last_seen'],
         })
 
@@ -143,25 +224,24 @@ def main():
 
     print(f"[{datetime.now().isoformat()}] Created {len(deduplicated):,} deduplicated records", file=sys.stderr)
 
-    # Create dataset
-    features = Features({
-        'name': Value('string'),
-        'versions': Value('string'),
-        'capabilities': Value('string'),
-        'last_seen': Value('string'),
-    })
-
-    dataset = Dataset.from_list(deduplicated, features=features)
+    # Handle push to hub
+    if args.push_to_hub:
+        push_to_hub(deduplicated, args.target_repo, split=args.target_split, token=args.token, private=args.private)
+        return
 
-    # Push to Hub
-    print(f"[{datetime.now().isoformat()}] Pushing deduplicated dataset to {args.target_repo}...", file=sys.stderr)
+    # Handle local output
+    if args.output:
+        out_file = open(args.output, 'w')
+    else:
+        out_file = sys.stdout
 
-    dataset.push_to_hub(
-        repo_id=args.target_repo,
-        commit_message=f"Update deduplicated dataset ({datetime.now().strftime('%Y-%m-%d %H:%M')})",
-    )
+    # Output as NDJSON
+    for client in deduplicated:
+        out_file.write(json.dumps(client) + '\n')
 
-    print(f"[{datetime.now().isoformat()}] Successfully pushed {len(deduplicated):,} deduplicated records to {args.target_repo}", file=sys.stderr)
+    if args.output:
+        out_file.close()
+        print(f"Output written to: {args.output}", file=sys.stderr)
 
 
 if __name__ == '__main__':