Upload 7 files

README.md

@@ -0,0 +1,239 @@
+---
+annotations_creators: []
+language_creators:
+- crowdsourced
+- expert-generated
+language:
+- code
+license:
+- other
+multilinguality:
+- multilingual
+pretty_name: github-code
+size_categories:
+- unknown
+source_datasets: []
+task_categories:
+- text-generation
+task_ids:
+- language-modeling
+---
+
+# GitHub Code Dataset
+
+## Dataset Description
+The GitHub Code dataset consists of 115M code files from GitHub in 32 programming languages with 60 extensions totaling in 1TB of data. The dataset was created from the public GitHub dataset on Google BiqQuery.
+
+### How to use it
+
+The GitHub Code dataset is a very large dataset so for most use cases it is recommended to make use of the streaming API of `datasets`. You can load and iterate through the dataset with the following two lines of code:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("codeparrot/github-code", streaming=True, split="train")
+print(next(iter(ds)))
+
+#OUTPUT:
+{
+ 'code': "import mod189 from './mod189';\nvar value=mod189+1;\nexport default value;\n",
+ 'repo_name': 'MirekSz/webpack-es6-ts',
+ 'path': 'app/mods/mod190.js',
+ 'language': 'JavaScript',
+ 'license': 'isc',
+ 'size': 73
+}
+```
+
+You can see that besides the code, repo name, and path also the programming language, license, and the size of the file are part of the dataset. You can also filter the dataset for any subset of the 30 included languages (see the full list below) in the dataset. Just pass the list of languages as a list. E.g. if your dream is to build a Codex model for Dockerfiles use the following configuration:
+
+```python
+ds = load_dataset("codeparrot/github-code", streaming=True, split="train", languages=["Dockerfile"])
+print(next(iter(ds))["code"])
+
+#OUTPUT:
+"""\
+FROM rockyluke/ubuntu:precise
+
+ENV DEBIAN_FRONTEND="noninteractive" \
+    TZ="Europe/Amsterdam"
+...
+"""
+```
+
+We also have access to the license of the origin repo of a file so we can filter for licenses in the same way we filtered for languages:
+ 
+```python
+ds = load_dataset("codeparrot/github-code", streaming=True, split="train", licenses=["mit", "isc"])
+
+licenses = []
+for element in iter(ds).take(10_000):
+    licenses.append(element["license"])
+print(Counter(licenses))
+
+#OUTPUT:
+Counter({'mit': 9896, 'isc': 104})
+```
+
+Naturally, you can also download the full dataset. Note that this will download ~300GB compressed text data and the uncompressed dataset will take up ~1TB of storage:
+```python
+ds = load_dataset("codeparrot/github-code", split="train")
+```
+
+## Data Structure
+
+### Data Instances
+
+```python
+{
+ 'code': "import mod189 from './mod189';\nvar value=mod189+1;\nexport default value;\n",
+ 'repo_name': 'MirekSz/webpack-es6-ts',
+ 'path': 'app/mods/mod190.js',
+ 'language': 'JavaScript',
+ 'license': 'isc',
+ 'size': 73
+}
+```
+
+### Data Fields
+
+|Field|Type|Description|
+|---|---|---|
+|code|string|content of source file|
+|repo_name|string|name of the GitHub repository|
+|path|string|path of file in GitHub repository|
+|language|string|programming language as inferred by extension|
+|license|string|license of GitHub repository|
+|size|int|size of source file in bytes|
+
+### Data Splits
+
+The dataset only contains a train split.
+
+## Languages
+
+The dataset contains 30 programming languages with over 60 extensions:
+
+```python
+{
+    "Assembly": [".asm"],
+    "Batchfile": [".bat", ".cmd"],
+    "C": [".c", ".h"],
+    "C#": [".cs"],
+    "C++": [".cpp", ".hpp", ".c++", ".h++", ".cc", ".hh", ".C", ".H"],
+    "CMake": [".cmake"],
+    "CSS": [".css"],
+    "Dockerfile": [".dockerfile", "Dockerfile"],
+    "FORTRAN": ['.f90', '.f', '.f03', '.f08', '.f77', '.f95', '.for', '.fpp'],
+    "GO": [".go"],
+    "Haskell": [".hs"],
+    "HTML":[".html"],
+    "Java": [".java"],
+    "JavaScript": [".js"],
+    "Julia": [".jl"],
+    "Lua": [".lua"],
+    "Makefile": ["Makefile"],
+    "Markdown": [".md", ".markdown"],
+    "PHP": [".php", ".php3", ".php4", ".php5", ".phps", ".phpt"],
+    "Perl": [".pl", ".pm", ".pod", ".perl"],
+    "PowerShell": ['.ps1', '.psd1', '.psm1'],
+    "Python": [".py"],
+    "Ruby": [".rb"],
+    "Rust": [".rs"],
+    "SQL": [".sql"],
+    "Scala": [".scala"],
+    "Shell": [".sh", ".bash", ".command", ".zsh"],
+    "TypeScript": [".ts", ".tsx"],
+    "TeX": [".tex"],
+    "Visual Basic": [".vb"]
+}
+```
+
+## Licenses
+Each example is also annotated with the license of the associated repository. There are in total 15 licenses:
+```python
+[
+  'mit',
+  'apache-2.0',
+  'gpl-3.0',
+  'gpl-2.0',
+  'bsd-3-clause',
+  'agpl-3.0',
+  'lgpl-3.0',
+  'lgpl-2.1',
+  'bsd-2-clause',
+  'cc0-1.0',
+  'epl-1.0',
+  'mpl-2.0',
+  'unlicense',
+  'isc',
+  'artistic-2.0'
+ ]
+```
+
+## Dataset Statistics
+
+The dataset contains 115M files and the sum of all the source code file sizes is 873 GB (note that the size of the dataset is larger due to the extra fields). A breakdown per language is given in the plot and table below:
+
+![dataset-statistics](https://huggingface.co/datasets/codeparrot/github-code/resolve/main/github-code-stats-alpha.png)
+
+|    | Language     |File Count| Size (GB)|
+|---:|:-------------|---------:|-------:|
+|  0 | Java         | 19548190 | 107.70 |
+|  1 | C            | 14143113 | 183.83 |
+|  2 | JavaScript   | 11839883 |  87.82 |
+|  3 | HTML         | 11178557 | 118.12 |
+|  4 | PHP          | 11177610 |  61.41 |
+|  5 | Markdown     |  8464626 |  23.09 |
+|  6 | C++          |  7380520 |  87.73 |
+|  7 | Python       |  7226626 |  52.03 |
+|  8 | C#           |  6811652 |  36.83 |
+|  9 | Ruby         |  4473331 |  10.95 |
+| 10 | GO           |  2265436 |  19.28 |
+| 11 | TypeScript   |  1940406 |  24.59 |
+| 12 | CSS          |  1734406 |  22.67 |
+| 13 | Shell        |  1385648 |   3.01 |
+| 14 | Scala        |   835755 |   3.87 |
+| 15 | Makefile     |   679430 |   2.92 |
+| 16 | SQL          |   656671 |   5.67 |
+| 17 | Lua          |   578554 |   2.81 |
+| 18 | Perl         |   497949 |   4.70 |
+| 19 | Dockerfile   |   366505 |   0.71 |
+| 20 | Haskell      |   340623 |   1.85 |
+| 21 | Rust         |   322431 |   2.68 |
+| 22 | TeX          |   251015 |   2.15 |
+| 23 | Batchfile    |   236945 |   0.70 |
+| 24 | CMake        |   175282 |   0.54 |
+| 25 | Visual Basic |   155652 |   1.91 |
+| 26 | FORTRAN      |   142038 |   1.62 |
+| 27 | PowerShell   |   136846 |   0.69 |
+| 28 | Assembly     |    82905 |   0.78 |
+| 29 | Julia        |    58317 |   0.29 |
+
+
+## Dataset Creation
+
+The dataset was created in two steps:
+1. Files of with the extensions given in the list above were retrieved from the GitHub dataset on BigQuery (full query [here](https://huggingface.co/datasets/codeparrot/github-code/blob/main/query.sql)). The query was executed on _Mar 16, 2022, 6:23:39 PM UTC+1_.
+2. Files with lines longer than 1000 characters and duplicates (exact duplicates ignoring whitespaces) were dropped (full preprocessing script [here](https://huggingface.co/datasets/codeparrot/github-code/blob/main/github_preprocessing.py)).
+
+## Considerations for Using the Data
+
+The dataset consists of source code from a wide range of repositories. As such they can potentially include harmful or biased code as well as sensitive information like passwords or usernames.
+
+## Releases
+
+You can load any older version of the dataset with the `revision` argument:
+
+```Python
+ds = load_dataset("codeparrot/github-code", revision="v1.0")
+```
+
+### v1.0
+- Initial release of dataset
+- The query was executed on _Feb 14, 2022, 12:03:16 PM UTC+1_
+
+### v1.1
+- Fix missing Scala/TypeScript
+- Fix deduplication issue with inconsistent Python `hash`
+- The query was executed on _Mar 16, 2022, 6:23:39 PM UTC+1_

data/train-00000-of-01126.parquet

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

gitattributes.txt

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text

github-code.py

@@ -0,0 +1,206 @@
+# 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 dataset."""
+
+import os
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+import datasets
+
+_REPO_NAME = "codeparrot/github-code"
+
+_LANG_TO_EXTENSION = {
+    "Assembly": [".asm"],
+    "Batchfile": [".bat", ".cmd"],
+    "C": [".c", ".h"],
+    "C#": [".cs"],
+    "C++": [".cpp", ".hpp", ".c++", ".h++", ".cc", ".hh", ".C", ".H"],
+    "CMake": [".cmake"],
+    "CSS": [".css"],
+    "Dockerfile": [".dockerfile", "Dockerfile"],
+    "FORTRAN": ['.f90', '.f', '.f03', '.f08', '.f77', '.f95', '.for', '.fpp'],
+    "GO": [".go"],
+    "Haskell": [".hs"],
+    "HTML":[".html"],
+    "Java": [".java"],
+    "JavaScript": [".js"],
+    "Julia": [".jl"],
+    "Lua": [".lua"],
+    "Makefile": ["Makefile"],
+    "Markdown": [".md", ".markdown"],
+    "PHP": [".php", ".php3", ".php4", ".php5", ".phps", ".phpt"],
+    "Perl": [".pl", ".pm", ".pod", ".perl"],
+    "PowerShell": ['.ps1', '.psd1', '.psm1'],
+    "Python": [".py"],
+    "Ruby": [".rb"],
+    "Rust": [".rs"],
+    "SQL": [".sql"],
+    "Scala": [".scala"],
+    "Shell": [".sh", ".bash", ".command", ".zsh"],
+    "TypeScript": [".ts", ".tsx"],
+    "TeX": [".tex"],
+    "Visual Basic": [".vb"]
+}
+
+_LICENSES = ['mit',
+ 'apache-2.0',
+ 'gpl-3.0',
+ 'gpl-2.0',
+ 'bsd-3-clause',
+ 'agpl-3.0',
+ 'lgpl-3.0',
+ 'lgpl-2.1',
+ 'bsd-2-clause',
+ 'cc0-1.0',
+ 'epl-1.0',
+ 'mpl-2.0',
+ 'unlicense',
+ 'isc',
+ 'artistic-2.0']
+
+_DESCRIPTION = """\
+The GitHub Code dataest consists of 115M code files from GitHub in 32 programming \
+languages with 60 extensions totalling in 1TB of text data. The dataset was created \
+from the GitHub dataset on BiqQuery.
+"""
+
+_HOMEPAGE = "https://cloud.google.com/blog/topics/public-datasets/github-on-bigquery-analyze-all-the-open-source-code/"
+
+
+_EXTENSION_TO_LANG = {}
+for lang in _LANG_TO_EXTENSION:
+    for extension in _LANG_TO_EXTENSION[lang]:
+        _EXTENSION_TO_LANG[extension] = lang
+
+
+        
+_LANG_CONFIGS = ["all"] + list(_LANG_TO_EXTENSION.keys())
+_LICENSE_CONFIGS = ["all"] + _LICENSES
+        
+class GithubCodeConfig(datasets.BuilderConfig):
+    """BuilderConfig for the GitHub Code dataset."""
+
+    def __init__(self, *args, languages=["all"], licenses=["all"], **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.
+            **kwargs: keyword arguments forwarded to super.
+        """
+        super().__init__(
+            *args,
+            name="+".join(languages)+"-"+"+".join(licenses),
+            **kwargs,
+        )
+        
+        languages = set(languages)
+        licenses = set(licenses)
+        
+        assert all([language in _LANG_CONFIGS for language in languages]), f"Language not in {_LANG_CONFIGS}."
+        assert all([license in _LICENSE_CONFIGS for license in licenses]), f"License not in {_LICENSE_CONFIGS}."
+        
+        if "all" in languages:
+            assert len(languages)==1, "Passed 'all' together with other languages."
+            self.filter_languages = False
+        else:
+            self.filter_languages = True
+            
+        if "all" in licenses:
+            assert len(licenses)==1, "Passed 'all' together with other licenses."
+            self.filter_licenses = False
+        else:
+            self.filter_licenses = True
+        
+        self.languages = set(languages)
+        self.licenses = set(licenses)
+
+
+        
+class GithubCode(datasets.GeneratorBasedBuilder):
+    """GitHub Code dataset."""
+
+    VERSION = datasets.Version("1.0.0")
+    
+    BUILDER_CONFIG_CLASS = GithubCodeConfig
+    BUILDER_CONFIGS = [GithubCodeConfig(languages=[lang], licenses=[license]) for lang in _LANG_CONFIGS
+                                                                        for license in _LICENSE_CONFIGS]
+    DEFAULT_CONFIG_NAME = "all-all"
+    
+    
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features({"code": datasets.Value("string"),
+                                        "repo_name": datasets.Value("string"),
+                                        "path": datasets.Value("string"), 
+                                        "language": datasets.Value("string"),
+                                        "license": datasets.Value("string"),
+                                        "size": datasets.Value("int32")}),
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            license="Multiple: see the 'license' field of each sample.",
+            
+        )
+
+    def _split_generators(self, dl_manager):
+        num_shards = 1126
+        data_files = [
+            f"data/train-{_index:05d}-of-{num_shards:05d}.parquet"
+            for _index in range(num_shards)
+        ]
+        files = dl_manager.download(data_files)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "files": files,
+                },
+            ),
+        ]
+
+    def _generate_examples(self, files):
+        key = 0
+        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['content'][0],
+                                    "repo_name": row['repo_name'][0],
+                                    "path": row['path'][0],
+                                    "license": license,
+                                    "language": lang,
+                                    "size": int(row['size'][0])}    
+                        key += 1
+
+                        
+def lang_from_name(name):
+    for extension in _EXTENSION_TO_LANG:
+        if name.endswith(extension):
+            return _EXTENSION_TO_LANG[extension]

github_preprocessing.py

@@ -0,0 +1,146 @@
+import gzip
+import multiprocessing
+import os
+import shutil
+import time
+from argparse import Namespace
+from collections import Counter
+import numpy as np
+from datasets import load_dataset, utils
+import re
+from huggingface_hub import Repository
+from multiprocessing import Pool
+from tqdm import tqdm
+
+# Settings
+config = {
+    "dataset_name": "./data/github",
+    "num_workers": 96,
+    "line_max": 1000,
+    "out_path": "./data/github-code",
+    "repo_name": "github-code",
+    "org": "lvwerra",
+    "shard_size": 1000 << 20}
+
+args = Namespace(**config)
+
+PATTERN = re.compile(r'\s+')
+
+
+def hash_func(text):
+    return hashlib.md5(re.sub(PATTERN, '', text).encode("utf-8")).hexdigest()
+
+def get_hash(example):
+    """Get hash of content field."""
+    return {"hash": hash_func(example["content"])}
+
+
+def line_stats(example):
+    """Calculates mean and max line length of file."""
+    line_lengths = [len(line) for line in example["content"].splitlines()]
+    return {"line_mean": np.mean(line_lengths), "line_max": max(line_lengths)}
+
+
+def alpha_stats(example):
+    """Calculates mean and max line length of file."""
+    alpha_frac = np.mean([c.isalnum() for c in example["content"]])
+    return {"alpha_frac": alpha_frac}
+
+
+def check_uniques(example, uniques):
+    """Check if current hash is still in set of unique hashes and remove if true."""
+    if example["hash"] in uniques:
+        uniques.remove(example["hash"])
+        return True
+    else:
+        return False
+
+
+def is_autogenerated(example, scan_width=5):
+    """Check if file is autogenerated by looking for keywords in the first few lines of the file."""
+    keywords = ["auto-generated", "autogenerated", "automatically generated"]
+    lines = example["content"].splitlines()
+    for _, line in zip(range(scan_width), lines):
+        for keyword in keywords:
+            if keyword in line.lower():
+                return {"autogenerated": True}
+    else:
+        return {"autogenerated": False}
+
+
+def preprocess(example):
+    """Chain all preprocessing steps into one function to not fill cache."""
+    results = dict()
+    results.update(get_hash(example))
+    results.update(line_stats(example))
+    return results
+
+
+def filter(example, uniques, args):
+    """Filter dataset with heuristics."""
+    if not check_uniques(example, uniques):
+        return False
+    elif example["line_max"] > args.line_max:
+        return False
+    else:
+        return True
+    
+def save_shard(shard_tuple):
+    """Save shard"""
+    filename, shard = shard_tuple
+    shard.to_parquet(filename)
+
+# Load dataset
+t_start = time.time()
+ds = load_dataset(args.dataset_name, split="train", chunksize=40<<20)
+print(f"Time to load dataset: {time.time()-t_start:.2f}")
+
+# Run preprocessing
+t_start = time.time()
+ds = ds.map(preprocess, num_proc=args.num_workers)
+print(f"Time to preprocess dataset: {time.time()-t_start:.2f}")
+print(ds)
+
+# Deduplicate hashes
+uniques = set(ds.unique("hash"))
+frac = len(uniques) / len(ds)
+print(f"Fraction of duplicates: {1-frac:.2%}")
+
+# Deduplicate data and apply heuristics
+t_start = time.time()
+ds = ds.filter(filter, fn_kwargs={"uniques": uniques, "args": args})
+ds = ds.remove_columns(["line_mean", "line_max", "copies", "hash"])
+print(f"Time to filter dataset: {time.time()-t_start:.2f}")
+print(f"Size of filtered dataset: {len(ds)}")
+
+
+# Save dataset in repo
+repo = Repository(
+        local_dir=args.out_path,
+        clone_from=args.org + "/" + args.repo_name,
+        repo_type="dataset",
+        private=True,
+        use_auth_token=True,
+        git_user="lvwerra",
+        git_email="[email protected]",
+        )
+
+os.mkdir(args.out_path + "/data")
+
+if ds._indices is not None:
+    dataset_nbytes = ds.data.nbytes * len(ds._indices) / len(ds.data)
+else:
+    dataset_nbytes = ds.data.nbytes
+
+num_shards = int(dataset_nbytes / args.shard_size) + 1
+print(f"Number of shards: {num_shards}")
+
+t_start = time.time()
+shards = (ds.shard(num_shards=num_shards, index=i, contiguous=True) for i in range(num_shards))
+filenames = (f"{args.out_path}/data/train-{index:05d}-of-{num_shards:05d}.parquet" for index in range(num_shards))
+
+with Pool(16) as p:
+    list(tqdm(p.imap_unordered(save_shard, zip(filenames, shards), chunksize=4), total=num_shards))
+print(f"Time to save dataset: {time.time()-t_start:.2f}")
+
+# To push to hub run `git add/commit/push` inside dataset repo folder

query.sql

@@ -0,0 +1,84 @@
+SELECT
+  f.repo_name,
+  f.path,
+  c.copies,
+  c.size,
+  c.content,
+  l.license
+FROM
+ (select f.*, row_number() over (partition by id order by path desc) as seqnum
+      from `bigquery-public-data.github_repos.files` AS f) f
+JOIN
+  `bigquery-public-data.github_repos.contents` AS c
+ON
+  f.id = c.id AND seqnum=1
+JOIN
+  `bigquery-public-data.github_repos.licenses` AS l
+ON
+  f.repo_name = l.repo_name
+WHERE
+  NOT c.binary
+  AND ((f.path LIKE '%.asm'
+      OR f.path LIKE '%.bat'
+      OR f.path LIKE '%.cmd'
+      OR f.path LIKE '%.c'
+      OR f.path LIKE '%.h'
+      OR f.path LIKE '%.cs'
+      OR f.path LIKE '%.cpp'
+      OR f.path LIKE '%.hpp'
+      OR f.path LIKE '%.c++'
+      OR f.path LIKE '%.h++'
+      OR f.path LIKE '%.cc'
+      OR f.path LIKE '%.hh'
+      OR f.path LIKE '%.C'
+      OR f.path LIKE '%.H'
+      OR f.path LIKE '%.cmake'
+      OR f.path LIKE '%.css'
+      OR f.path LIKE '%.dockerfile'
+      OR f.path LIKE '%.f90'
+      OR f.path LIKE '%.f'
+      OR f.path LIKE '%.f03'
+      OR f.path LIKE '%.f08'
+      OR f.path LIKE '%.f77'
+      OR f.path LIKE '%.f95'
+      OR f.path LIKE '%.for'
+      OR f.path LIKE '%.fpp'
+      OR f.path LIKE '%.go'
+      OR f.path LIKE '%.hs'
+      OR f.path LIKE '%.html'
+      OR f.path LIKE '%.java'
+      OR f.path LIKE '%.js'
+      OR f.path LIKE '%.jl'
+      OR f.path LIKE '%.lua'
+      OR f.path LIKE '%.md'
+      OR f.path LIKE '%.markdown'
+      OR f.path LIKE '%.php'
+      OR f.path LIKE '%.php3'
+      OR f.path LIKE '%.php4'
+      OR f.path LIKE '%.php5'
+      OR f.path LIKE '%.phps'
+      OR f.path LIKE '%.phpt'
+      OR f.path LIKE '%.pl'
+      OR f.path LIKE '%.pm'
+      OR f.path LIKE '%.pod'
+      OR f.path LIKE '%.perl'
+      OR f.path LIKE '%.ps1'
+      OR f.path LIKE '%.psd1'
+      OR f.path LIKE '%.psm1'
+      OR f.path LIKE '%.py'
+      OR f.path LIKE '%.rb'
+      OR f.path LIKE '%.rs'
+      OR f.path LIKE '%.sql'
+      OR f.path LIKE '%.scala'
+      OR f.path LIKE '%.sh'
+      OR f.path LIKE '%.bash'
+      OR f.path LIKE '%.command'
+      OR f.path LIKE '%.zsh'
+      OR f.path LIKE '%.ts'
+      OR f.path LIKE '%.tsx'
+      OR f.path LIKE '%.tex'
+      OR f.path LIKE '%.vb'
+      OR f.path LIKE '%Dockerfile'
+      OR f.path LIKE '%Makefile')
+    AND (c.size BETWEEN 0
+      AND 1048575))