Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 mega_licensed_corpus_redacted.txt filter=lfs diff=lfs merge=lfs -text
+python_files_elaborated.txt filter=lfs diff=lfs merge=lfs -text
+python_files_elaborated_metadata.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -11,32 +11,42 @@ dataset_type: code
 tags:
   - code
   - python
-  - code-generation
 size_categories:
   - 100K<n⩽1M
 task_categories:
   - text-generation
-task_ids:
-  - code-completion
 ---
 
-# GitHub-Python
+# GitHub-Python — Licensed & Elaborated Variants
 
-A **767 MB** corpus of permissively-licensed Python code drawn from public GitHub repositories.  
-The dataset was created to support training and evaluation of **code-completion / generation** models.
+This repository ships **two complementary Python-code corpora** extracted from
+public GitHub:
+
+- **Licensed Subset** – strictly _permissive-licensed_ files suitable for
+  commercial redistribution / model training (main corpus used in our
+  experiments).
+- **Elaborated Collection** – a broader crawl that additionally contains files
+  under _copyleft_ or unclear licenses (GPL/AGPL/LGPL, etc.). Useful for
+  analysis or pre-training where license mixing is acceptable.
+
+Both variants target **code-completion / generation** research.
 
 ## Dataset at a glance
 
-|                  | Value                                         |
-| ---------------- | --------------------------------------------- |
-| Files            | 53,017 `.py` files                            |
-| Repositories     | 16,447                                        |
-| Owners           | 12,515                                        |
-| Compressed size  | 732 MB (`mega_licensed_corpus_redacted.txt`)  |
-| Vocabulary       | 443,431 tokens (`custom_tokens_vocab.txt`)    |
-| Time period      | Commits ≥ 2015-01-01                          |
-| License coverage | MIT, Apache-2.0, BSD, ISC, Unlicense          |
-| Removed secrets  | ✅ – all hard-coded secrets/API keys redacted |
+|                     | **Licensed Subset** | **Elaborated Collection** |
+| ------------------- | ------------------- | ------------------------- |
+| Files (.py)         | 53,017              | 186,066                   |
+| Unique repositories | 16,447              | 59,852                    |
+| Repository owners   | 12,515              | 43,517                    |
+| Compressed size     | 732 MB              | 2.4 GB \*                 |
+| Vocabulary (tokens) | 443,431             | 443,431 †                 |
+| License coverage    | Permissive only     | Mixed (perm. + copyleft)  |
+| Secrets redacted    | ✅                  | ⚠️ not guaranteed         |
+| Time window         | ≥ 2015-01-01        | ≥ 2015-01-01              |
+
+\* estimated – elaborated corpus is distributed as raw file list, not a single
+text file.  
+† same tokenizer file is shared by both variants.
 
 Numbers were obtained from the final redacted corpus and companion metadata.
 
@@ -46,8 +56,10 @@ Numbers were obtained from the final redacted corpus and companion metadata.
 
 ```
 huggingface_dataset/
- ├─ mega_licensed_corpus_redacted.txt   # concatenated code corpus
- ├─ python_files.txt                    # list of raw file URLs (1-per-line)
+ ├─ mega_licensed_corpus_redacted.txt      # Licensed Subset – concatenated code
+ ├─ python_files.txt                       # Licensed Subset – raw file URLs
+ ├─ python_files_elaborated.txt            # Elaborated Collection – raw file URLs
+ ├─ python_files_elaborated_metadata.csv   # Elaborated Collection metadata
  └─ custom_tokens_vocab.txt             # `<token>\t<id>` vocabulary file
 ```
 
@@ -64,6 +76,27 @@ code of one file.
 
 ---
 
+## Dataset variants
+
+### 1. Licensed Subset (`mega_licensed_corpus_redacted.txt`)
+
+• 53 K permissively-licensed files (MIT/BSD/Apache/ISC/Unlicense).  
+• All API keys & credentials removed.  
+• Ready for redistribution & commercial use (respect upstream NOTICE files).
+
+### 2. Elaborated Collection (`python_files_elaborated.txt`)
+
+• 186 K files from a much larger crawl.  
+• Contains **GPL / LGPL / AGPL and other copyleft** licenses.  
+• Shipped _as URL list_ + metadata CSV; you must download the files yourself
+(`datasets.load_dataset` streaming, `wget`, etc.).  
+• **No license filtering or secret-redaction performed** – use with caution.
+
+When first loading the dataset, decide which variant aligns with your use case
+(e.g. proprietary model training → Licensed Subset only).
+
+---
+
 ## Collection methodology
 
 1. **Repository discovery**

create_elaborated_metadata_table.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Create metadata table for the elaborated GitHub Python dataset.
+
+This script parses the python_files_elaborated.txt file containing GitHub URLs
+and extracts repository metadata (owner, repo name, file path).
+It generates a CSV file with this information and prints statistics.
+
+The elaborated dataset contains more files than the licensed subset and
+may include repositories with various licenses (not just permissive ones).
+"""
+
+import csv
+import os
+import re
+import pandas as pd
+from collections import Counter, defaultdict
+from tqdm import tqdm
+from urllib.parse import urlparse
+
+# Input and output files
+ELABORATED_FILES_LIST = "python_files_elaborated.txt"
+LICENSED_FILES_LIST = "python_files.txt"
+OUTPUT_CSV = "python_files_elaborated_metadata.csv"
+
+# Regular expression to parse GitHub raw URLs
+# Format: https://raw.githubusercontent.com/OWNER/REPO/BRANCH/PATH
+GITHUB_RAW_PATTERN = r"https://raw\.githubusercontent\.com/([^/]+)/([^/]+)/[^/]+/(.*)"
+
+
+def parse_github_url(url):
+    """
+    Parse a GitHub raw URL to extract owner, repo name, and file path.
+    
+    Args:
+        url (str): GitHub raw URL
+        
+    Returns:
+        tuple: (owner, repo_name, file_path) or None if URL doesn't match pattern
+    """
+    match = re.match(GITHUB_RAW_PATTERN, url)
+    if match:
+        owner, repo_name, file_path = match.groups()
+        return owner, repo_name, file_path
+    return None
+
+
+def create_metadata_table(file_list_path):
+    """
+    Create a metadata table from a list of GitHub URLs.
+    
+    Args:
+        file_list_path (str): Path to file containing GitHub URLs
+        
+    Returns:
+        list: List of dictionaries with metadata
+    """
+    metadata = []
+    
+    # Read URLs from file
+    with open(file_list_path, "r") as f:
+        urls = [line.strip() for line in f if line.strip()]
+    
+    print(f"Processing URLs from {file_list_path}...")
+    
+    # Parse each URL and extract metadata
+    for url in tqdm(urls, desc="Parsing URLs"):
+        parsed = parse_github_url(url)
+        if parsed:
+            owner, repo_name, file_path = parsed
+            metadata.append({
+                "owner": owner,
+                "repo_name": repo_name,
+                "file_path": file_path,
+                "url": url
+            })
+    
+    return metadata
+
+
+def generate_statistics(metadata, dataset_name):
+    """
+    Generate and print statistics for the dataset.
+    
+    Args:
+        metadata (list): List of dictionaries with metadata
+        dataset_name (str): Name of the dataset for display
+    """
+    # Count unique repositories and owners
+    repos = set((item["owner"], item["repo_name"]) for item in metadata)
+    owners = set(item["owner"] for item in metadata)
+    
+    # Count files by repository
+    repo_counts = Counter((item["owner"], item["repo_name"]) for item in metadata)
+    top_repos = repo_counts.most_common(10)
+    
+    # Count files by owner
+    owner_counts = Counter(item["owner"] for item in metadata)
+    top_owners = owner_counts.most_common(5)
+    
+    # Count file extensions
+    extensions = Counter(os.path.splitext(item["file_path"])[1] for item in metadata)
+    
+    # Print statistics
+    print(f"\n=== {dataset_name} Statistics ===")
+    print(f"Total files: {len(metadata)}")
+    print(f"Unique repositories: {len(repos)}")
+    print(f"Unique repository owners: {len(owners)}")
+    
+    print("\nTop 10 repositories by file count:")
+    for (owner, repo), count in top_repos:
+        print(f"  {owner}/{repo}: {count} files")
+    
+    print("\nFile extensions:")
+    for ext, count in extensions.most_common():
+        if ext:  # Skip empty extensions
+            print(f"  {ext}: {count} files")
+    
+    print("\nTop 5 repository owners:")
+    for owner, count in top_owners:
+        print(f"  {owner}: {count} files")
+    
+    return {
+        "total_files": len(metadata),
+        "unique_repos": len(repos),
+        "unique_owners": len(owners),
+        "top_repos": top_repos,
+        "top_owners": top_owners,
+        "extensions": extensions
+    }
+
+
+def compare_datasets(elaborated_stats, licensed_stats):
+    """
+    Compare statistics between elaborated and licensed datasets.
+    
+    Args:
+        elaborated_stats (dict): Statistics for elaborated dataset
+        licensed_stats (dict): Statistics for licensed dataset
+    """
+    print("\n=== Dataset Comparison ===")
+    print(f"Elaborated dataset: {elaborated_stats['total_files']} files")
+    print(f"Licensed dataset: {licensed_stats['total_files']} files")
+    print(f"Additional files in elaborated dataset: {elaborated_stats['total_files'] - licensed_stats['total_files']} files")
+    
+    # Calculate percentage increase
+    pct_increase = ((elaborated_stats['total_files'] / licensed_stats['total_files']) - 1) * 100
+    print(f"Percentage increase: {pct_increase:.1f}%")
+    
+    # Compare repositories
+    print(f"\nElaborated dataset: {elaborated_stats['unique_repos']} repositories")
+    print(f"Licensed dataset: {licensed_stats['unique_repos']} repositories")
+    
+    # Compare owners
+    print(f"\nElaborated dataset: {elaborated_stats['unique_owners']} repository owners")
+    print(f"Licensed dataset: {licensed_stats['unique_owners']} repository owners")
+    
+    # Find repositories unique to elaborated dataset
+    elaborated_repos = set((owner, repo) for (owner, repo), _ in elaborated_stats['top_repos'])
+    licensed_repos = set((owner, repo) for (owner, repo), _ in licensed_stats['top_repos'])
+    unique_to_elaborated = elaborated_repos - licensed_repos
+    
+    if unique_to_elaborated:
+        print("\nTop repositories unique to elaborated dataset:")
+        for owner, repo in list(unique_to_elaborated)[:5]:
+            print(f"  {owner}/{repo}")
+
+
+def main():
+    # Process elaborated dataset
+    elaborated_metadata = create_metadata_table(ELABORATED_FILES_LIST)
+    
+    # Save to CSV
+    with open(OUTPUT_CSV, "w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=["owner", "repo_name", "file_path", "url"], 
+                               quoting=csv.QUOTE_MINIMAL)
+        writer.writeheader()
+        writer.writerows(elaborated_metadata)
+    
+    print(f"Metadata saved to {OUTPUT_CSV}")
+    
+    # Generate statistics for elaborated dataset
+    elaborated_stats = generate_statistics(elaborated_metadata, "Elaborated Dataset")
+    
+    # Process licensed dataset for comparison
+    if os.path.exists(LICENSED_FILES_LIST):
+        licensed_metadata = create_metadata_table(LICENSED_FILES_LIST)
+        licensed_stats = generate_statistics(licensed_metadata, "Licensed Dataset")
+        
+        # Compare datasets
+        compare_datasets(elaborated_stats, licensed_stats)
+    else:
+        print(f"Warning: {LICENSED_FILES_LIST} not found. Cannot compare datasets.")
+
+
+if __name__ == "__main__":
+    main()

python_files_elaborated.txt

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

python_files_elaborated_metadata.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46359841e7cf01ebd2232ff24f310644481798ba85138db310dee8fb29417bbd
+size 22895119