stop iterating through dataset after max_samples is reached and read language filter columns first

saves a loooot of time generating the train split, e.g. if you only need 100k samples from the python subset or so

github-code-clean.py

@@ -1,19 +1,3 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""GitHub Code clean dataset."""
-
 import os
 
 import pyarrow as pa
@@ -93,12 +77,12 @@ _LICENSE_CONFIGS = ["all"] + _LICENSES
 class GithubCodeConfig(datasets.BuilderConfig):
     """BuilderConfig for the GitHub Code dataset."""
 
-    def __init__(self, *args, languages=["all"], licenses=["all"], **kwargs):
+    def __init__(self, *args, languages=["all"], licenses=["all"], max_samples=None, **kwargs):
         """BuilderConfig for the GitHub Code dataset.
-
         Args:
             languages (:obj:`List[str]`): List of languages to load.
             licenses (:obj:`List[str]`): List of licenses to load.
+            max_samples (:obj:`int`, optional): Maximum number of samples to generate (for early stopping).
             **kwargs: keyword arguments forwarded to super.
         """
         super().__init__(
@@ -127,7 +111,7 @@ class GithubCodeConfig(datasets.BuilderConfig):
         
         self.languages = set(languages)
         self.licenses = set(licenses)
-
+        self.max_samples = max_samples
 
         
 class GithubCode(datasets.GeneratorBasedBuilder):
@@ -174,32 +158,75 @@ class GithubCode(datasets.GeneratorBasedBuilder):
 
     def _generate_examples(self, files):
         key = 0
+        yielded_count = 0
+        max_samples = self.config.max_samples
+        
         for file_idx, file in enumerate(files):
-            with open(file, "rb") as f:
-                parquet_file = pq.ParquetFile(f)
-                for batch_idx, record_batch in enumerate(parquet_file.iter_batches(batch_size=10_000)):
-                    pa_table = pa.Table.from_batches([record_batch])
-                    for row_index in range(pa_table.num_rows):
-                        row = pa_table.slice(row_index, 1).to_pydict()
-                        
-                        lang = lang_from_name(row['path'][0])
-                        license = row["license"][0]
-                        
-                        if self.config.filter_languages and not lang in self.config.languages:
-                            continue
-                        if self.config.filter_licenses and not license in self.config.licenses:
-                            continue
-                        
-                        yield key, {"code": row['code'][0],
-                                    "repo_name": row['repo_name'][0],
-                                    "path": row['path'][0],
-                                    "license": license,
-                                    "language": lang,
-                                    "size": int(row['size'][0])}    
+            # Early stopping at file level
+            if max_samples is not None and yielded_count >= max_samples:
+                return
+            
+            parquet_file = pq.ParquetFile(file)
+            
+            # Process each row group separately (Parquet internal chunking)
+            for rg_idx in range(parquet_file.num_row_groups):
+                # Early stopping at row group level
+                if max_samples is not None and yielded_count >= max_samples:
+                    return
+                
+                # PASS 1: Read ONLY filter columns from this row group
+                filter_table = parquet_file.read_row_group(rg_idx, columns=['path', 'license'])
+                
+                paths = filter_table['path'].to_pylist()
+                licenses = filter_table['license'].to_pylist()
+                
+                # Find matching indices within this row group
+                matching_indices = []
+                matching_langs = []
+                
+                for row_index in range(len(paths)):
+                    if max_samples is not None and yielded_count + len(matching_indices) >= max_samples:
+                        break
+                    
+                    lang = lang_from_name(paths[row_index])
+                    license = licenses[row_index]
+                    
+                    if self.config.filter_languages and lang not in self.config.languages:
+                        continue
+                    if self.config.filter_licenses and license not in self.config.licenses:
+                        continue
+                    
+                    matching_indices.append(row_index)
+                    matching_langs.append(lang)
+                
+                # PASS 2: Read full row group ONLY if there are matches
+                if matching_indices:
+                    # Now read ALL columns for this row group
+                    full_table = parquet_file.read_row_group(rg_idx)
+                    
+                    # Extract only matching rows
+                    filtered_table = full_table.take(matching_indices)
+                    batch_dict = filtered_table.to_pydict()
+                    
+                    # Yield all matching rows
+                    for i in range(len(matching_indices)):
+                        yield key, {
+                            "code": batch_dict['code'][i],
+                            "repo_name": batch_dict['repo_name'][i],
+                            "path": batch_dict['path'][i],
+                            "license": batch_dict['license'][i],
+                            "language": matching_langs[i],
+                            "size": int(batch_dict['size'][i])
+                        }
                         key += 1
+                        yielded_count += 1
+                
+                if max_samples is not None and yielded_count >= max_samples:
+                    return
 
                         
 def lang_from_name(name):
     for extension in _EXTENSION_TO_LANG:
         if name.endswith(extension):
-            return _EXTENSION_TO_LANG[extension]
+            return _EXTENSION_TO_LANG[extension]
+    return None