itp-interface 1.0.0__py3-none-any.whl

itp_interface/scripts/setup.sh

@@ -0,0 +1,228 @@
+#!/bin/bash
+
+if [[ ! -d "src/itp_interface/scripts" ]]; then
+    # Raise an error if the scripts directory is not present
+    echo "Please run this script from the root of the repository, cannot find src/scripts"
+    exit 1
+fi
+# Default Lean version
+lean3_version="3.42.1"
+lean4_version="4.7.0-rc2" # "nightly" # "4.7.0" # "stable"
+lean_type="lean4" # For Lean 3
+lean_repo="leanprover-community/lean" # For Lean 3
+# Check if lean_version is passed as an argument
+if [[ $# -eq 1 ]]; then
+    lean_type=$1
+    afp_folder=$HOME
+fi
+
+if [[ $# -eq 2 ]]; then
+    lean_type=$1
+    afp_folder=$2
+fi
+
+if [[ $lean_type == "lean" ]]; then
+    lean_version=$lean3_version
+    lean_repo="leanprover-community/lean"
+elif [[ $lean_type == "lean4" ]]; then
+    lean_version=$lean4_version
+    lean_repo="leanprover/lean4"
+else
+    echo "Invalid Lean version, please choose between lean or lean4"
+    exit 1
+fi
+
+# Don't run without activating conda
+# Check if Conda is activated
+conda_status=$(conda info | grep "active environment" | cut -d ':' -f 2 | tr -d '[:space:]')
+if [[ $conda_status == "None" ]] || [[ $conda_status == "base" ]]; then
+    echo "Please activate conda environment before running this script"
+    exit 1
+fi
+echo "Setting up ITP Interface ..."
+echo "[NOTE] The installation needs manual intervention on some steps. Please choose the appropriate option when prompted."
+conda install pip
+conda_bin=$(conda info | grep "active env location" | cut -d ':' -f 2 | tr -d '[:space:]')
+pip_exe="$conda_bin/bin/pip"
+ls -l $pip_exe
+echo "Installing dependencies..."
+echo "Installing Elan (Lean version manager) ..."
+# # For Lean:
+# # https://leanprover-community.github.io/install/debian_details.html
+curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh
+echo "Installed Elan (Lean version manager) successfully!"
+source $HOME/.elan/env
+echo "Installing $lean_type ($lean_repo:$lean_version)..."
+elan toolchain install $lean_repo:$lean_version
+elan override set $lean_repo:$lean_version
+echo "Installed $lean_type ($lean_repo:$lean_version) successfully!"
+export PATH=$PATH:$HOME/.elan/bin
+echo "Clone all git submodules..."
+git submodule update --init --recursive
+echo "Cloned all git submodules successfully!"
+echo "Building Coq's CompCert project..."
+pushd ./src/data/benchmarks
+echo "Installing Coq switch..."
+opam switch create CompCert 4.07.1
+eval $(opam env --switch=CompCert --set-switch)
+opam repo add coq-released https://coq.inria.fr/opam/released
+eval `opam config env`
+opam pin -yn add coq 8.10.2
+opam pin -yn add menhir 20190626
+opam install -y coq-serapi coq menhir
+if [[ ! -f "CompCert/Makefile.config" ]]; then
+     (cd CompCert && ./configure x86_64-linux)
+fi
+make -C CompCert -j `nproc`
+popd
+echo "Building Coq's Simple Benchmark..."
+pushd ./src/data/test/coq/custom_group_theory
+cd theories
+make
+cd ..
+popd
+echo "Building Coq's Simple Benchmark done!"
+echo "Coq's Setup complete!"
+
+# Python dependencies
+echo "Installing Python dependencies..."
+$pip_exe install --user -r requirements.txt
+
+# Only build Lean's Simple Benchmark if Lean 3 is selected
+if [[ $lean_type == "lean" ]]; then
+    echo "Building Lean's projects ..."
+    (
+        # Build Lean's projects
+        echo "Building miniF2F..."
+        echo "This may take a while... (don't underestimate the time taken to build miniF2F, meanwhile you can take a coffee break!)"
+        pushd ./src/data/benchmarks
+        set -euv
+        cd miniF2F
+        leanpkg configure
+        leanproject get-mathlib-cache # This allows us to use .olean files from mathlib without building them again
+        leanproject build
+        popd
+        echo "miniF2F built successfully!"
+    ) || exit 1
+    echo "Building Lean's Simple Benchmark..."
+    pushd ./src/data/test/lean_proj
+    leanproject build
+    popd
+    echo "Building Lean's Simple Benchmark done!"
+    echo "Building Lean's projects done!"
+    echo "Lean's Setup complete!"
+    echo "Downloading ReProver benchmarks..."
+    (
+        # Download ReProver benchmarks
+        echo "Running download.sh from src/data/benchmarks/lean-dojo..."
+        ./src/data/benchmarks/lean-dojo/download.sh
+        echo "Downloaded ReProver benchmarks successfully!"
+    ) || exit 1
+fi
+if [[ $lean_type == "lean4" ]]; then
+    echo "Building Lean 4's projects ..."
+    (
+        # Build Lean 4's projects
+        echo "Building Lean 4's Simple Benchmark..."
+        pushd ./src/data/test/lean4_proj
+        lake build lean4_proj
+        popd
+        echo "Building Lean 4's Simple Benchmark done!"
+    ) || exit 1
+    echo "Building Lean 4's interface REPL..."
+    (
+        # Build Lean 4's interface REPL
+        pushd ./imports/repl
+        lake build repl
+        popd
+        echo "Lean 4's interface REPL built successfully!"
+    ) || exit 1
+    echo "Building Lean 4's Mathlib..."
+    (
+        # Build Lean 4's Mathlib
+        echo "Building Lean 4's Mathlib..."
+        echo "This may take a while... (don't underestimate the time taken to build Lean 4's Mathlib, meanwhile you can take a coffee break!)"
+        pushd src/data/test/Mathlib
+        lake exe cache get > /dev/null
+        lake build Mathlib
+        popd
+        echo "Lean 4's Mathlib built successfully!"
+    ) || exit 1
+    echo "Building Lean 4's projects done!"
+fi
+
+# Download Isabelle
+# First check if Isabelle is already installed
+# default_isabelle_dir="$HOME/Isabelle2022" # Don't change this, otherwise PISA will not work
+# issabell_installed=false
+# if [[ -d "$default_isabelle_dir" ]]; then
+#     echo "Isabelle is already installed at $default_isabelle_dir"
+#     echo "If you want to reinstall Isabelle, please delete the directory $default_isabelle_dir and run this script again"
+#     issabell_installed=true
+# fi
+# # Else download Isabelle
+# if [[ $issabell_installed == false ]]; then
+#     echo "Installing SDKMAN..."
+#     curl -s "https://get.sdkman.io" | bash
+#     echo "Installed SDKMAN successfully!"
+#     echo "Installing Java 11 and SBT..."
+#     source $HOME/.sdkman/bin/sdkman-init.sh
+#     sdk install java 11.0.11-open
+#     echo "Installed Java 11 successfully!"
+#     echo "Installing SBT..."
+#     sdk install sbt
+#     echo "Installed SBT successfully!"
+#     echo "Downloading Isabelle..."
+#     wget https://isabelle.in.tum.de/website-Isabelle2022/dist/Isabelle2022_linux.tar.gz
+#     echo "Downloaded Isabelle successfully!"
+#     echo "Extracting Isabelle..."
+#     # Extract Isabelle in the $default_isabelle_dir
+#     tar -xzf Isabelle2022_linux.tar.gz -C $HOME
+#     echo "Installed Isabelle successfully!"
+#     echo "Cleaning up..."
+#     rm Isabelle2022_linux.tar.gz
+#     echo "Cleaned up!"
+#     echo "Adding Isabelle to PATH..."
+#     export PATH=$PATH:$default_isabelle_dir/bin
+#     echo "export PATH=$PATH:$default_isabelle_dir/bin" >> ~/.bashrc
+#     isabelle build -b -D $default_isabelle_dir/src/HOL/ -j 20
+# fi
+# pushd src/itp_interface/pisa
+# sbt compile
+# sbt assembly
+# popd
+# echo "Isabelle Setup complete!"
+
+# echo "ITP Interface Setup complete!"
+
+# echo "Building AFP"
+# afp_installed_built=false
+# if [[ -d "$afp_folder" ]]; then
+#     echo "AFP is already installed at $afp_folder"
+#     echo "If you want to reinstall AFP, please delete the directory $afp_folder and run this script again"
+#     afp_installed_built=true
+# fi
+
+# afp_version="2022-12-06"
+# if [[ $afp_installed_built == false ]]; then
+#     mkdir -p $afp_folder
+#     echo "Downloading AFP..."
+#     wget https://www.isa-afp.org/release/afp-$afp_version.tar.gz
+#     echo "Downloaded AFP successfully!"
+#     echo "Extracting AFP..."
+#     # Extract AFP in the $afp_folder
+#     tar -xzf afp-$afp_version.tar.gz -C $afp_folder
+#     echo "Extracted AFP successfully!"
+#     echo "Cleaning up..."
+#     afp_name=$(ls $afp_folder)
+#     export AFP="$afp_folder/$afp_name/thys"
+#     echo "$AFP"
+#     rm afp-$afp_version.tar.gz
+#     echo "Cleaned up!"
+#     echo "Building AFP..."
+#     export ISABELLE_BUILD_OPTIONS="timeout=3600"
+#     export ML_OPTIONS="--maxheap 10000"
+#     isabelle build -b -D $AFP -j 35
+# fi
+
+# echo "AFP Setup complete!"

itp_interface/tools/basic_utils.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+
+import sys
+
+root_dir = f"{__file__.split('itp_interface')[0]}"
+if root_dir not in sys.path:
+    sys.path.append(root_dir)
+import typing
+from collections import Counter
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json
+
+@dataclass_json
+@dataclass
+class Stats(object):
+    avg: float = 0.0
+    min: float = 0.0
+    max: float = 0.0
+    std: float = 0.0
+    median: float = 0.0
+    count: int = 0
+    quartiles: typing.Dict[int, float] = field(default_factory=dict)
+    percentile_with_sigmas : typing.Dict[int, float] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if len(self.quartiles) == 0:
+            self.quartiles[1] = 0.0
+            self.quartiles[2] = 0.0
+            self.quartiles[3] = 0.0
+        if len(self.percentile_with_sigmas) == 0:
+            self.percentile_with_sigmas[-3] = 0.0
+            self.percentile_with_sigmas[-2] = 0.0
+            self.percentile_with_sigmas[-1] = 0.0
+            self.percentile_with_sigmas[0] = 0.0
+            self.percentile_with_sigmas[1] = 0.0
+            self.percentile_with_sigmas[2] = 0.0
+            self.percentile_with_sigmas[3] = 0.0
+
+class CounterUtils:
+    @staticmethod
+    def percentile(counter: Counter, p: float) -> float:
+        assert isinstance(counter, Counter)
+        assert isinstance(p, float)
+        assert 0 <= p <= 1
+        n = sum(counter.values())
+        current = 0
+        percentile_value = None
+        r = p * (n - 1) + 1
+        ri = int(r)
+        rf = r - ri
+        val_ri = None
+        val_ri1 = None
+        for k, v in sorted(counter.items()):
+            if current + v >= ri and val_ri is None:
+                val_ri = k
+            if current + v >= ri + 1 and val_ri1 is None:
+                val_ri1 = k
+            current += v
+            if val_ri is not None and val_ri1 is not None:
+                percentile_value = val_ri + rf * (val_ri1 - val_ri)
+                break
+        if val_ri1 is None:
+            percentile_value = val_ri
+        assert percentile_value is not None
+        return percentile_value
+    
+    @staticmethod
+    def find_rank(counter: Counter, value: float) -> float:
+        assert isinstance(counter, Counter)
+        assert isinstance(value, float)
+        current = 0
+        prev_k = None
+        current_k = None
+        n = sum(counter.values())
+        for k, v in sorted(counter.items()):
+            current_k = k
+            if k >= value:
+                break
+            prev_k = k
+            current += v
+        interpolation_factor = 0
+        if prev_k is None:
+            prev_k = current_k - 1
+        elif current_k == prev_k:
+            interpolation_factor = 0
+        else:
+            interpolation_factor = (value - prev_k) / (current_k - prev_k)
+
+        rank = current + interpolation_factor
+        return rank/n
+        
+
+    @staticmethod
+    def mean(counter: Counter) -> float:
+        assert isinstance(counter, Counter)
+        current = 0
+        n = 0
+        for k, v in counter.items():
+            current += k * v
+            n += v
+        mean_value = current / n
+        return mean_value
+
+    @staticmethod
+    def median(counter: Counter) -> float:
+        return CounterUtils.percentile(counter, 0.5)
+
+    @staticmethod
+    def max(counter: Counter) -> float:
+        return max(counter)
+
+    @staticmethod
+    def min(counter: Counter) -> float:
+        return min(counter)
+
+    @staticmethod
+    def std(counter: Counter) -> float:
+        counter_squared = Counter()
+        for k, v in counter.items():
+            counter_squared[k*k] = v
+        return (CounterUtils.mean(counter_squared) - CounterUtils.mean(counter)**2)**0.5
+    
+    @staticmethod
+    def get_stats(counter: Counter) -> Stats:
+        stats = Stats()
+        stats.avg = CounterUtils.mean(counter)
+        stats.min = CounterUtils.min(counter)
+        stats.max = CounterUtils.max(counter)
+        stats.std = CounterUtils.std(counter)
+        stats.median = CounterUtils.median(counter)
+        stats.count = sum(counter.values())
+        stats.quartiles[1] = CounterUtils.percentile(counter, 0.25)
+        stats.quartiles[2] = CounterUtils.percentile(counter, 0.5)
+        stats.quartiles[3] = CounterUtils.percentile(counter, 0.75)
+        for k in stats.percentile_with_sigmas:
+            stats.percentile_with_sigmas[k] = CounterUtils.find_rank(counter, stats.avg + k * stats.std)
+        return stats
+
+if __name__ == "__main__":
+    data = [1, 1, 1, 1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    counter = Counter(data)
+    print(f"counter: {counter}")
+    print(f"percentile (0%): {CounterUtils.percentile(counter, 0.0)}")
+    print(f"percentile (25%): {CounterUtils.percentile(counter, 0.25)}")
+    print(f"percentile (50%): {CounterUtils.percentile(counter, 0.5)}")
+    print(f"percentile (75%): {CounterUtils.percentile(counter, 0.75)}")
+    mean = CounterUtils.mean(counter)
+    print(f"mean: {mean}")
+    print(f"median: {CounterUtils.median(counter)}")
+    print(f"max: {CounterUtils.max(counter)}")
+    print(f"min: {CounterUtils.min(counter)}")
+    std = CounterUtils.std(counter)
+    print(f"std: {std}")
+    print(f"find_rank (0): {CounterUtils.find_rank(counter, 0.0)}")
+    print(f"u + std: {mean + std}")
+    print(f"u - std: {mean - std}")
+    p_u_plus_std = CounterUtils.find_rank(counter, mean + std)
+    p_u_minus_std = CounterUtils.find_rank(counter, mean - std)
+    print(f"find_rank (u + std): {p_u_plus_std}")
+    print(f"find_rank (u - std): {p_u_minus_std}")
+    print(f"percentile (u + std): {CounterUtils.percentile(counter, p_u_plus_std)}")
+    print(f"percentile (u - std): {CounterUtils.percentile(counter, p_u_minus_std)}")
+    print(f"find_rank (u + 2 * std): {CounterUtils.find_rank(counter, mean + 2 * std)}")
+    print(f"find_rank (u - 2 * std): {CounterUtils.find_rank(counter, mean - 2 * std)}")
+    print(f"find_rank (u + 3 * std): {CounterUtils.find_rank(counter, mean + 3 * std)}")
+    print(f"find_rank (u - 3 * std): {CounterUtils.find_rank(counter, mean - 3 * std)}")
+    print(f"find_rank (10): {CounterUtils.find_rank(counter, 10.0)}")
+    print(f"find_rank (11): {CounterUtils.find_rank(counter, 11.0)}")
+    all_stats = CounterUtils.get_stats(counter)
+    print(f"all_stats: {all_stats}")
+    print(f"Serialized = \n{all_stats.to_json()}")
+    pass

itp_interface/tools/bin_packing.py

@@ -0,0 +1,61 @@
+import random
+import copy
+
+def best_fit_packing(bin_sizes, item_sizes):
+    """
+    Best fit algorithm for bin packing problem with no empty bins, modified to ensure
+    no non-zero capacity bin is left empty if possible. It minimizes the absolute difference
+    between the bin capacity and the packed items, without creating new bins.
+    :param bin_sizes: list of bin sizes (each bin's maximum capacity)
+    :param item_sizes: list of item sizes (sizes of items to be packed)
+    :returns: list of lists containing the items packed in each bin
+    """
+    sorted_item_sizes_with_index = sorted(enumerate(item_sizes), key=lambda x: x[1], reverse=True)
+    bins = [[] for _ in range(len(bin_sizes))]
+    bin_remaining_capacity = copy.deepcopy(bin_sizes)
+    # Reduce the bin capacity a bit to ensure no empty bins
+    for i, size in enumerate(bin_remaining_capacity):
+        if size > 0:
+            bin_remaining_capacity[i] -= 1
+    bin_remaining_capacity = sorted(enumerate(bin_remaining_capacity), key=lambda x: x[1], reverse=True)
+    items_packed = set()
+    for item_index, item_size in sorted_item_sizes_with_index:
+        best_fit_index = -1
+        best_fit_remaining_capacity = float('inf')
+        sorted_bin_idx = -1
+        for _idx, (i, remaining_capacity) in enumerate(bin_remaining_capacity):
+            # don't consider bins with zero capacity
+            if bin_sizes[i] == 0:
+                continue
+            if remaining_capacity >= item_size and remaining_capacity - item_size < best_fit_remaining_capacity:
+                best_fit_index = i
+                sorted_bin_idx = _idx
+                best_fit_remaining_capacity = remaining_capacity - item_size
+        if best_fit_index != -1:
+            bins[best_fit_index].append(item_index)
+            bin_remaining_capacity[sorted_bin_idx] = (best_fit_index, best_fit_remaining_capacity)
+            items_packed.add(item_index)
+            bin_remaining_capacity = sorted(bin_remaining_capacity, key=lambda x: x[1], reverse=True)
+    # Randomly pack the remaining items in the bins
+    while len(items_packed) < len(item_sizes):
+        remaining_items = [i for i in range(len(item_sizes)) if i not in items_packed]
+        random.shuffle(remaining_items)
+        for idx, item_index in enumerate(remaining_items):
+            bin_idx = idx % len(bins)
+            if bin_sizes[bin_idx] == 0:
+                continue
+            bins[idx % len(bins)].append(item_index)
+            items_packed.add(item_index)
+    return bins
+
+if __name__ == '__main__':
+    # Example usage
+    item_sizes = [0, 0, 0, 0, 0, 2, 5, 1, 0, 3, 2, 0, 1, 2, 23, 0, 0, 0, 25, 1, 0, 0, 0, 4, 0, 0, 10, 0, 1, 6, 4, 1, 3, 0, 0, 17, 0, 8, 0, 17, 0, 0, 0, 7, 0, 0, 4, 0, 0, 4, 0, 0, 0, 3, 1, 0, 0, 9, 0, 0, 15, 7, 9, 2, 1, 0, 10, 15, 2, 4, 0, 0, 0, 1, 0, 0, 9, 19, 3, 0, 0, 0, 0, 0, 20, 0, 6, 23, 0, 5, 11, 0, 0, 0, 13, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 6, 3, 0, 12, 1, 3, 2, 14, 6, 16, 4, 0, 0, 0, 1, 2, 12, 0, 31, 13, 0, 15, 16, 0, 0, 4, 1, 0, 0, 0, 1, 3, 2, 0, 7, 0, 0, 0, 0, 0, 1, 0, 0, 7, 1, 0, 0, 0, 0, 4, 0, 0, 2, 0, 0, 2, 5, 0, 0, 2, 0, 3, 1, 0, 0, 0, 8, 0, 1, 0, 0, 0, 5, 0, 0, 0, 0, 2, 38, 1, 0, 1, 1, 1, 0, 2, 28, 0, 0, 0, 1, 3, 0, 13, 1, 0, 1, 5, 1, 0, 0, 0, 0, 1, 6, 0, 10, 0, 2, 1, 1, 1, 4, 0, 7, 1, 2, 14, 0, 0, 2, 0]
+    print(f"Total items: {len(item_sizes)}")
+    sum_item_sizes = sum(item_sizes)
+    bin_sizes = [int(0.925 * sum_item_sizes), int(0.0375 * sum_item_sizes), int(0.0375 * sum_item_sizes)]
+    bins = best_fit_packing(bin_sizes, item_sizes)
+    for i, b in enumerate(bins):
+        items = [item_sizes[j] for j in b]
+        print(f'Bin {i + 1}: {items}, Total size: {sum(items)}, Remaining capacity: {bin_sizes[i] - sum(items)}, Bin size: {bin_sizes[i]}')
+    print(f"All items packed: {sum([len(b) for b in bins]) == len(item_sizes)}")

itp_interface/tools/cache.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+
+import sys
+root_dir = f"{__file__.split('itp_interface')[0]}"
+if root_dir not in sys.path:
+    sys.path.append(root_dir)
+import typing
+from threading import Lock
+
+class SimpleLruCache(object):
+    KiB = 2**10
+    MiB = 2**20
+    GiB = 2**30
+    def __init__(self, max_size_in_bytes: int = 100*MiB):
+        assert max_size_in_bytes is not None, "Max size in MiB cannot be None"
+        assert max_size_in_bytes > 0, "Max size in MiB must be greater than 0"
+        self.max_size_in_bytes = max_size_in_bytes
+        self.cache = {}
+        self.cache_order = []
+        self.cache_size_in_bytes = 0
+        self.mutex = Lock()
+    
+    def add_to_cache(self, key: str, value: typing.Any, size_in_bytes: int) -> typing.List[str]:
+        assert key is not None, "File path cannot be None"
+        assert value is not None, "File contents cannot be None"
+        self.mutex.acquire()
+        removed_items = []
+        try:
+            self._try_remove_from_cache(key)
+            self.cache[key] = (value, size_in_bytes)
+            self.cache_order.append(key)
+            self.cache_size_in_bytes += size_in_bytes
+            while self.cache_size_in_bytes > self.max_size_in_bytes:
+                last_used_key = self.cache_order[0]
+                if self._try_remove_lru_key():
+                    removed_items.append(last_used_key)
+        finally:
+            self.mutex.release()
+        return removed_items
+    
+    def get_from_cache(self, key: str):
+        assert key is not None, "File path cannot be None"
+        self.mutex.acquire()
+        try:
+            if key in self.cache:
+                self.cache_order.remove(key)
+                self.cache_order.append(key)
+                value, _ = self.cache[key]
+                return value
+            return None
+        finally:
+            self.mutex.release()
+    
+    def try_remove_from_cache(self, key: str) -> bool:
+        self.mutex.acquire()
+        try:
+            return self._try_remove_from_cache(key)
+        finally:
+            self.mutex.release()
+    
+    def clear_cache(self):
+        self.mutex.acquire()
+        try:
+            while self._try_remove_lru_key():
+                pass
+        finally:
+            self.mutex.release()
+
+    # define in operator
+    def __contains__(self, key: str):
+        self.mutex.acquire()
+        try:
+            return key in self.cache
+        finally:
+            self.mutex.release()
+
+    # unsafe method
+    def _try_remove_lru_key(self) -> bool:
+        if len(self.cache_order) > 0:
+            self._try_remove_from_cache(self.cache_order[0])
+            return True
+        return False
+    
+    # unsafe method
+    def _try_remove_from_cache(self, key: str) -> bool:
+        assert key is not None, "File path cannot be None"
+        if key in self.cache:
+            val, size = self.cache.pop(key)
+            self.cache_size_in_bytes -= size
+            self.cache_order.remove(key)
+            del val
+            return True
+        return False

itp_interface/tools/coq_build_spec.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+import sys
+root_dir = f"{__file__.split('itp_interface')[0]}"
+if root_dir not in sys.path:
+    sys.path.append(root_dir)
+import typing
+import argparse
+from dataclasses_json import dataclass_json
+from dataclasses import dataclass, field
+
+
+@dataclass_json
+@dataclass
+class CoqBuildSpec:
+    project_name: str
+    train_files: typing.List[str] = field(default_factory=list)
+    test_files: typing.List[str] = field(default_factory=list)
+    build_partition: typing.Optional[str] = None
+    build_command: typing.Optional[str] = None
+    timeout : typing.Optional[int] = None
+    switch: typing.Optional[str] = None
+
+if __name__ == "__main__":
+    # take the project split as argument
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--project_split", type=str, required=False, default="data/proverbot9001/coqgym_projs_splits.json", help="path to the project split")
+    args = parser.parse_args()
+    with open(args.project_split, "r") as f:
+        project_splits = CoqBuildSpec.schema().loads(f.read(), many=True)
+        print(project_splits)