Upload split_tokens.py

split_tokens.py

@@ -0,0 +1,102 @@
+import json
+import re
+
+## split the code into multiple tokens so that it is not too long
+
+def count_tokens(code):
+    # Count the number of tokens in the code
+    #tokens = re.findall(r'\b\w+\b', code)
+    return len(code)
+
+def split_code(code, max_tokens=2048):
+    # Split the code into smaller chunks based on classes, functions, and other logical units
+    class_pattern = re.compile(r'(?:class|struct|interface)\s+\w+\s*[\(\{]')
+    function_pattern = re.compile(r'(?:def|function|func|fn)\s+\w+\s*\([^)]*\)\s*\{')
+    import_pattern = re.compile(r'(?:import|include|require)\s+')
+    comment_pattern = re.compile(r'(?://|#).*')
+
+    # Remove comments from the code
+    code = comment_pattern.sub('', code)
+
+    # Find the starting points of classes, functions, and other logical units
+    class_starts = [match.start() for match in class_pattern.finditer(code)]
+    function_starts = [match.start() for match in function_pattern.finditer(code)]
+    import_starts = [match.start() for match in import_pattern.finditer(code)]
+    logical_units = sorted(class_starts + function_starts + import_starts + [len(code)])
+
+    chunks = []
+    start_index = 0
+    for end_index in logical_units:
+        chunk = code[start_index:end_index].strip()
+        if chunk:
+            token_count = count_tokens(chunk)
+            if token_count <= max_tokens:
+                chunks.append(chunk)
+                start_index = end_index
+            else:
+                # If the chunk is too long, split it into smaller chunks
+                sub_chunks = split_chunk(chunk, max_tokens)
+                chunks.extend(sub_chunks)
+                start_index = end_index
+
+    return chunks
+
+def split_chunk(chunk, max_tokens):
+    # Split a chunk into smaller sub-chunks based on the maximum token limit
+    sub_chunks = []
+    start_index = 0
+    while start_index < len(chunk):
+        end_index = start_index + max_tokens
+        sub_chunk = chunk[start_index:end_index].strip()
+        sub_chunks.append(sub_chunk)
+        start_index = end_index
+    return sub_chunks
+
+def find_split_index(code, max_tokens):
+    # Find the index to split the code chunk
+    token_count = 0
+    for i, char in enumerate(code):
+        if char.isspace():
+            token_count += 1
+            if token_count > max_tokens:
+                return i
+    return len(code)
+
+def process_json_file(input_file, output_file):
+    # Read the input JSON file
+    with open(input_file, 'r') as file:
+        data = json.load(file)
+
+    # Process each entry in the JSON data
+    output_data = []
+    for entry in data:
+        code = entry['content']
+        token_count = count_tokens(code)
+        if code != "":
+            if token_count > 2048:
+                # Split the code into smaller chunks
+                chunks = split_code(code)
+
+                # Create separate entries for each chunk
+                for chunk in chunks:
+                    output_data.append(json.dumps({"text": chunk}))
+                    if len(chunk)>2048:
+                        print("Chunks len: ", len(chunk))
+                        print(chunk)
+                        break
+            else:
+                # Create a single entry for the code
+                output_data.append(json.dumps({"text": code}))
+
+    # Save the output data to a new JSON file without square brackets
+    with open(output_file, 'w') as file:
+        file.write('\n'.join(output_data))
+
+    print(f"Processing completed. Results saved to '{output_file}'.")
+
+# Specify the input and output file paths
+input_file = '../zkml-dataset/dataset.json'
+output_file = 'tokenized_code_data.json'
+
+# Process the JSON file
+process_json_file(input_file, output_file)