Upload folder using huggingface_hub

README.md

@@ -0,0 +1 @@
+This is the repository for LFX Mentorship Term-3 2024 for the project "Create an LLM app with deep understanding of a GitHub repo" under CNCF - Wasmedge

scripts/.gitignore

@@ -0,0 +1,4 @@
+Helper
+*.csv
+checkpoint.py
+upload.py

scripts/Data_fetch/github_parser.py

@@ -0,0 +1,57 @@
+import requests
+import csv
+
+
+GITHUB_TOKEN = "" # Replace with your actual GitHub token
+
+def get_github_contents(repo_url):
+    parts = repo_url.rstrip('/').split('/')
+    user = parts[-2]
+    repo = parts[-1]
+
+    api_url = f"https://api.github.com/repos/{user}/{repo}/contents/"
+
+    headers = {
+        "Authorization": f"token {GITHUB_TOKEN}"
+    }
+
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+
+    return response.json()
+
+def process_contents(contents, paths=[], parent_path=""):
+    headers = {
+        "Authorization": f"token {GITHUB_TOKEN}"
+    }
+
+    for item in contents:
+        path = parent_path + item['name']
+        if item['type'] == 'dir':
+            dir_response = requests.get(item['url'], headers=headers)
+            dir_response.raise_for_status()
+            dir_contents = dir_response.json()
+            process_contents(dir_contents, paths, path + "/")
+        else:
+            file_response = requests.get(item['download_url'], headers=headers)
+            file_response.raise_for_status()
+            file_content = file_response.text
+            paths.append({"Path": path, "Content": file_content})
+
+    return paths
+
+def write_to_csv(data, output_file):
+    with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
+        fieldnames = ['Path', 'Content']
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+
+        writer.writeheader()
+        for row in data:
+            writer.writerow(row)
+
+if __name__ == "__main__":
+    repo_url = input("Enter GitHub repository URL: ")
+    contents = get_github_contents(repo_url)
+    paths = process_contents(contents)
+    write_to_csv(paths, "quickjs_all.csv")
+    print("CSV file 'quickjs_all.csv' generated successfully.")

scripts/Data_fetch/list_file_types.py

@@ -0,0 +1,66 @@
+import requests
+import mimetypes
+from collections import defaultdict
+import os
+
+GITHUB_TOKEN = "" # Replace with your actual GitHub personal access token
+
+def get_github_contents(repo_url):
+    parts = repo_url.rstrip('/').split('/')
+    user = parts[-2]
+    repo = parts[-1]
+    
+    api_url = f"https://api.github.com/repos/{user}/{repo}/contents/"
+    
+    headers = {
+        "Authorization": f"token {GITHUB_TOKEN}"
+    }
+    
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+    
+    return response.json()
+
+def list_file_extensions(contents, file_extensions=None, parent_path=""):
+    if file_extensions is None:
+        file_extensions = defaultdict(int)
+
+    for item in contents:
+        path = parent_path + item['name']
+        
+        if item['type'] == 'dir':
+            dir_url = item['url']
+            headers = {
+                "Authorization": f"token {GITHUB_TOKEN}"
+            }
+            dir_response = requests.get(dir_url, headers=headers)
+            
+            if dir_response.status_code == 200:
+                dir_contents = dir_response.json()
+                if isinstance(dir_contents, list):
+                    list_file_extensions(dir_contents, file_extensions, path + "/")
+                else:
+                    print(f"Unexpected directory contents at {path}: {dir_contents}")
+            else:
+                print(f"Failed to fetch directory contents at {path}. Status code: {dir_response.status_code}")
+        else:
+            # Get the file extension
+            _, file_extension = os.path.splitext(item['name'])
+            
+            if file_extension:
+                file_extensions[file_extension] += 1
+            else:
+                file_extensions["no_extension"] += 1 
+
+    return file_extensions
+
+def get_file_extensions_in_repo(repo_url):
+    contents = get_github_contents(repo_url)
+    file_extensions = list_file_extensions(contents)
+    return dict(file_extensions)
+
+if __name__ == "__main__":
+    repo_url = input("Enter GitHub repository URL: ")
+    file_extensions = get_file_extensions_in_repo(repo_url)
+    for extension, count in file_extensions.items():
+        print(f"{extension}: {count} files")

scripts/Data_fetch/local_parser.py

@@ -0,0 +1,47 @@
+import os
+import csv
+import sys
+
+csv.field_size_limit(10**9)
+
+def process_local_repo(repo_path, paths=[]):
+    for root, dirs, files in os.walk(repo_path):
+        for file in files:
+            file_path = os.path.join(root, file)
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                file_content = f.read()
+            relative_path = os.path.relpath(file_path, repo_path)
+            extension = os.path.splitext(relative_path)[1]
+            if extension == '.md':
+                formatted_content = f"The following is a markdown document located at {relative_path}\n------\n{file_content}\n------"
+            elif extension == '.rs':
+                formatted_content = f"```rust:{relative_path}\n{file_content}\n```"
+            elif extension == '.css':
+                formatted_content = f"```css:{relative_path}\n{file_content}\n```"
+            elif extension == '.html':
+                formatted_content = f"```html:{relative_path}\n{file_content}\n```"
+            elif extension == '.json':
+                formatted_content = f"```json:{relative_path}\n{file_content}\n```"
+            elif extension == '.sh':
+                formatted_content = f"```bash:{relative_path}\n{file_content}\n```"
+            elif extension == '.py':
+                formatted_content = f"```python:{relative_path}\n{file_content}\n```"
+            elif extension == '.js':
+                formatted_content = f"```javascript:{relative_path}\n{file_content}\n```"
+            else:
+                formatted_content = f"The following document is located at {relative_path}\n------\n{file_content}\n------"
+            paths.append({"FormattedContent": formatted_content})
+    return paths
+
+def write_to_csv(data, output_file):
+    with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
+        writer = csv.writer(csvfile)
+        for row in data:
+            writer.writerow([row['FormattedContent']])
+
+if __name__ == "__main__":
+    repo_path = input("Enter the local repository path: ")
+    paths = process_local_repo(repo_path)
+    output_csv = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\output\local_repo\docs\qucik_js_js.csv"
+    write_to_csv(paths, output_csv)
+    print(f"CSV file '{output_csv}' generated successfully.")

scripts/Data_fetch/ocr.py

@@ -0,0 +1,60 @@
+import requests
+import csv
+import mimetypes
+from io import BytesIO
+from PIL import Image
+from surya.ocr import run_ocr
+from surya.model.detection.model import load_model as load_det_model, load_processor as load_det_processor
+from surya.model.recognition.model import load_model as load_rec_model
+from surya.model.recognition.processor import load_processor as load_rec_processor
+
+def get_github_contents(repo_url):
+    parts = repo_url.rstrip('/').split('/')
+    user = parts[-2]
+    repo = parts[-1]
+    
+    api_url = f"https://api.github.com/repos/{user}/{repo}/contents/"
+    
+    response = requests.get(api_url)
+    response.raise_for_status()
+    
+    return response.json()
+
+def process_contents(contents, paths=[], parent_path=""):
+    langs = ["en"]
+    det_processor, det_model = load_det_processor(), load_det_model()
+    rec_model, rec_processor = load_rec_model(), load_rec_processor()
+    
+    for item in contents:
+        path = parent_path + item['name']
+        if item['type'] == 'dir':
+            dir_contents = requests.get(item['url']).json()
+            process_contents(dir_contents, paths, path + "/")
+        else:
+            mime_type, _ = mimetypes.guess_type(item['name'])
+            if mime_type and mime_type.split('/')[0] == 'image':
+                image_content = requests.get(item['download_url']).content
+                image = Image.open(BytesIO(image_content))
+                predictions = run_ocr([image], [langs], det_model, det_processor, rec_model, rec_processor)
+                paths.append({"path": path, "content": ""})
+    
+    return paths
+
+def write_to_csv(data, output_file):
+    if data:
+        with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
+            fieldnames = ['path', 'content']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            
+            writer.writeheader()
+            for row in data:
+                writer.writerow(row)
+    else:
+        print("No data to write to CSV.")
+
+if __name__ == "__main__":
+    repo_url = input("Enter GitHub repository URL: ")
+    contents = get_github_contents(repo_url)
+    paths = process_contents(contents)
+    write_to_csv(paths, "repo_ocr.csv")
+    print(f"CSV file 'repo_ocr.csv' generated successfully with {len(paths)} entries.")

scripts/Data_fetch/pdf_parser.py

@@ -0,0 +1,60 @@
+import requests
+import csv
+import os
+import mimetypes
+import PyPDF2
+def get_github_contents(repo_url):
+    parts = repo_url.rstrip('/').split('/')
+    user = parts[-2]
+    repo = parts[-1]
+    api_url = f"https://api.github.com/repos/{user}/{repo}/contents/"
+    response = requests.get(api_url)
+    response.raise_for_status()
+    
+    return response.json()
+def process_contents(contents, paths=[], parent_path=""):
+    for item in contents:
+        path = parent_path + item['name']
+        if item['type'] == 'dir':
+            dir_contents = requests.get(item['url']).json()
+            process_contents(dir_contents, paths, path + "/")
+        else:
+            extension = '.' + item['name'].split('.')[-1] if '.' in item['name'] else ''
+            if extension == '.pdf':
+                file_response = requests.get(item['download_url'])
+                pdf_path = "Output/" + item['name']
+                # Save the PDF locally
+                with open(pdf_path, 'wb') as f:
+                    f.write(file_response.content)
+                paths.append({"path": pdf_path, "content": file_response.content})
+    return paths
+
+def extract_text_from_pdf(pdf_file_path):
+    pdf_reader = PyPDF2.PdfReader(pdf_file_path)
+    pages_content = []
+    for page_num in range(len(pdf_reader.pages)):
+        page = pdf_reader.pages[page_num]
+        text = page.extract_text()
+        pages_content.append(text)
+    return pages_content
+
+def save_pages_to_csv(pages_content, output_csv_file):
+    with open(output_csv_file, 'w', newline='', encoding='utf-8') as file:
+        writer = csv.writer(file)
+        writer.writerow(["Page", "Content"]) 
+        for i, content in enumerate(pages_content):
+            writer.writerow([i + 1, content])
+
+if __name__ == "__main__":
+    repo_url = input("Enter GitHub repository URL: ")
+    contents = get_github_contents(repo_url)
+    paths = process_contents(contents)
+    
+    for pdf_data in paths:
+        pdf_file_path = pdf_data["path"]
+        print(f"Processing {pdf_file_path}") 
+        pages_content = extract_text_from_pdf(pdf_file_path)        
+        csv_output_path = pdf_file_path.replace('.pdf', '_pages.csv')
+        save_pages_to_csv(pages_content, csv_output_path)
+        print(f"Extracted content from {pdf_file_path} and saved to {csv_output_path}")
+    print("All PDF files have been processed and converted to CSV.")

scripts/Data_fetch/readme.md

@@ -0,0 +1,5 @@
+1. List_file_types will help to list various file types present in a repo.( Important for knowing various file types present inside the repo)
+2. Repo_parser allows to copy all the contents of the repo into a csv file with path of various files in 1 column and it's contents in another.
+3. Code_parser allows to copy only those files that have code of specific languages. (Useful when a particular language or a framework is to be targeted).
+4. OCR to convert images or other such files with text data in the background.
+5. PDF_parser allows to fetch PDF files and convert them to a csv file with path, page number and contents as columns.

scripts/Data_fetch/repo2text_parser.py

@@ -0,0 +1,101 @@
+import csv
+import os
+
+def parse_text_file(input_file):
+    data = []
+    current_path = None
+    current_content = []
+    
+    with open(input_file, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+    
+    i = 0
+    while i < len(lines):
+        line = lines[i].strip()
+        
+        # Check for file start marker
+        if line == '---' and i + 1 < len(lines) and 'File:' in lines[i + 1]:
+            # If we have existing content, save it
+            if current_path and current_content:
+                data.append({
+                    "Path": current_path,
+                    "Content": ''.join(current_content)
+                })
+                current_content = []
+            
+            # Extract the new file path
+            current_path = lines[i + 1].split('File:')[1].strip()
+            i += 2  # Skip the File: line
+            
+            # Skip the closing '---' of the file header if it exists
+            if i < len(lines) and lines[i].strip() == '---':
+                i += 1
+                
+            continue
+        
+        # If we have a current path, collect all content including front matter
+        if current_path:
+            current_content.append(lines[i] + '\n')
+        
+        i += 1
+    
+    # Don't forget to add the last file
+    if current_path and current_content:
+        data.append({
+            "Path": current_path,
+            "Content": ''.join(current_content)
+        })
+    
+    return data
+
+def transform_and_write_csv(data, output_csv):
+    with open(output_csv, mode='w', newline='', encoding='utf-8') as outfile:
+        writer = csv.writer(outfile)
+        for row in data:
+            path = row.get('Path')
+            if not path:
+                continue
+                
+            content = row.get('Content', '')
+            extension = os.path.splitext(path)[1].lower()
+
+            if extension == '.md':
+                new_content = f"The following is a markdown document located at {path}\n------\n{content}\n------"
+            elif extension == '.rs':
+                new_content = f"```rust:{path}\n{content}\n```"
+            elif extension == '.sh':
+                new_content = f"```bash:{path}\n{content}\n```"
+            elif extension == '.py':
+                new_content = f"```python:{path}\n{content}\n```"
+            elif extension == '.js':
+                new_content = f"```javascript:{path}\n{content}\n```"
+            elif extension == '.json':
+                new_content = f"```json:{path}\n{content}\n```"
+            elif extension == '.txt':
+                new_content = f"The following is a plain text file located at {path}\n------\n{content}\n------"
+            elif extension == '.toml':
+                new_content = f"```toml:{path}\n{content}\n```"
+            elif extension == '.jsx':
+                new_content = f"```jsx:{path}\n{content}\n```"
+            elif extension == '.css':
+                new_content = f"```css:{path}\n{content}\n```"
+            elif extension == '.java':
+                new_content = f"```java:{path}\n{content}\n```"
+            elif extension == '.hpp':
+                new_content = f"```hpp:{path}\n{content}\n```"
+            elif extension == '.c':
+                new_content = f"```c:{path}\n{content}\n```"
+            elif extension == '.yml':
+                new_content = f"```yml:{path}\n{content}\n```"
+            elif extension == '.xml':
+                new_content = f"```xml:{path}\n{content}\n```"
+            else:
+                new_content = f"The following document is located at {path}\n------\n{content}\n------"
+            writer.writerow([new_content])
+
+if __name__ == "__main__":
+    input_file = input("Enter the path of your text file: ")
+    final_output_csv = "wasmedge.csv"
+    parsed_data = parse_text_file(input_file)
+    transform_and_write_csv(parsed_data, final_output_csv)
+    print(f"Transformed CSV file '{final_output_csv}' generated successfully.")

scripts/Data_fetch/repopack_parser.py

@@ -0,0 +1,84 @@
+import csv
+import os
+
+def parse_text_file(input_file):
+    data = []
+    current_path = None
+    current_content = []
+
+    with open(input_file, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+    inside_file_block = False
+
+    for line in lines:
+        if line.strip() == '================':
+            if inside_file_block and current_path and current_content:
+                data.append({
+                    "Path": current_path.strip(),
+                    "Content": ''.join(current_content).strip()
+                })
+                current_path = None
+                current_content = []
+                inside_file_block = False
+        elif line.startswith('File:'):
+            current_path = line.split('File: ')[1].strip()
+            inside_file_block = True
+        else:
+            if inside_file_block:
+                current_content.append(line)
+
+    if current_path and current_content:
+        data.append({
+            "Path": current_path.strip(),
+            "Content": ''.join(current_content).strip()
+        })
+    return data
+
+def transform_and_write_csv(data, output_csv):
+    with open(output_csv, mode='w', newline='', encoding='utf-8') as outfile:
+        writer = csv.writer(outfile)
+        for row in data:
+            path = row['Path']
+            content = row['Content']
+            extension = os.path.splitext(path)[1]
+
+            if extension == '.md':
+                new_content = f"The following is a markdown document located at {path}\n------\n{content}\n------"
+            elif extension == '.rs':
+                new_content = f"```rust:{path}\n{content}\n```"
+            elif extension == '.sh':
+                new_content = f"```bash:{path}\n{content}\n```"
+            elif extension == '.py':
+                new_content = f"```python:{path}\n{content}\n```"
+            elif extension == '.js':
+                new_content = f"```javascript:{path}\n{content}\n```"
+            elif extension == '.json':
+                new_content = f"```json:{path}\n{content}\n```"
+            elif extension == '.txt':
+                new_content = f"The following is a plain text file located at {path}\n------\n{content}\n------"
+            elif extension == '.toml':
+                new_content = f"```toml:{path}\n{content}\n```"
+            elif extension == '.jsx':
+                new_content = f"```jsx:{path}\n{content}\n```"
+            elif extension == '.css':
+                new_content = f"```css:{path}\n{content}\n```"
+            elif extension == '.java':
+                new_content == f"```java:{path}\n{content}\n```"
+            elif extension == '.hpp':
+                f"```hpp:{path}\n{content}\n```"
+            elif extension == '.c':
+                f"```c:{path}\n{content}\n```"
+            elif extension == '.yml':
+                new_content == f"```yml:{path}\n{content}\n```"
+            elif extension == '.xml':
+                new_content == f"```xml:{path}\n{content}\n```"
+            else:
+                new_content = f"The following document is located at {path}\n------\n{content}\n------"
+            writer.writerow([new_content])
+
+if __name__ == "__main__":
+    input_file = input("Enter the path of your text file: ")
+    final_output_csv = "wasmedge.csv"
+    parsed_data = parse_text_file(input_file)
+    transform_and_write_csv(parsed_data, final_output_csv)
+    print(f"Transformed CSV file '{final_output_csv}' generated successfully.")

scripts/Helper/chunking.py

@@ -0,0 +1,32 @@
+import pandas as pd
+
+df = pd.read_csv('Output/summary/eth_md_summary.csv')
+def truncate_content(content, max_tokens=7000):
+    words = content.split()
+    return ' '.join(words[:max_tokens])
+
+df['Content'] = df['Content'].apply(lambda x: truncate_content(x))
+df['Summary and Q&A'] = df['Summary and Q&A'].apply(lambda x: truncate_content(x))
+
+df.to_csv('Output/summary/eth_md_summary_trun.csv', index=False)
+
+'''
+import pandas as pd
+
+df = pd.read_csv('input_file.csv')
+
+def split_content(row, max_words=5000):
+    content = row['Content']
+    words = content.split()
+    chunks = [words[i:i + max_words] for i in range(0, len(words), max_words)]
+    return [{'Path': row['Path'], 'Content': ' '.join(chunk)} for chunk in chunks]
+
+new_rows = []
+
+for index, row in df.iterrows():
+    new_rows.extend(split_content(row))
+
+new_df = pd.DataFrame(new_rows)
+
+new_df.to_csv('output_file.csv', index=False)
+'''

scripts/Helper/cleaner.py

@@ -0,0 +1,11 @@
+import pandas as pd
+
+file_path = '/home/aru/Desktop/Github_analyser/Output/split_summary/wasmedge_split.csv' 
+df = pd.read_csv(file_path)
+
+df_cleaned = df.dropna(subset=['Content'])
+
+output_file_path = '/home/aru/Desktop/Github_analyser/Output/split_summary/wasmedge_split_cleam.csv'  
+df_cleaned.to_csv(output_file_path, index=False)
+
+print("Rows with empty 'Content' have been removed.")

scripts/Helper/count.py

@@ -0,0 +1,28 @@
+import csv
+
+def count_words_in_csv(input_file, output_file):
+    # Set the CSV field size limit to a large value, avoiding the overflow issue
+    csv.field_size_limit(10**7)  # 10 million, a high but safe limit
+    
+    # Open the input file with utf-8 encoding
+    with open(input_file, 'r', encoding='utf-8') as infile:
+        reader = csv.reader(infile)
+        
+        # Prepare the data for the output file
+        output_data = [["Original Content", "Word Count"]]
+        
+        # Iterate through each row, count words, and add to output data
+        for row in reader:
+            content = row[0]  # Get the content from the single column
+            word_count = len(content.split())  # Count the words
+            output_data.append([content, word_count])
+    
+    # Write the output data to the output CSV file
+    with open(output_file, 'w', newline='', encoding='utf-8') as outfile:
+        writer = csv.writer(outfile)
+        writer.writerows(output_data)
+    
+    print(f"Word count added to '{output_file}' successfully.")
+
+# Usage example
+count_words_in_csv(r"C:\Users\91745\OneDrive\Desktop\Github_analyser\output\local_repo\docs\quick_js_js.csv", "quickjsjs_count.csv")

scripts/Helper/counter.py

@@ -0,0 +1,50 @@
+import pandas as pd
+
+# Read the CSV, forcing it into a single column by specifying an unusual separator
+df = pd.read_csv(r'C:\Users\91745\OneDrive\Desktop\Github_analyser\output\local_repo\final_repo\llamaedge_repopack.csv', sep='\n', header=None)
+
+# Rename the column to 'Content'
+df.columns = ['Content']
+
+# Define the word count function
+def count_words(text):
+    if isinstance(text, str):
+        return len(text.split())
+    else:
+        return 0
+
+# Apply the word count function and add the result as a new column
+df['Content_Word_Count'] = df['Content'].apply(count_words)
+
+# Write to a new CSV without headers
+df.to_csv('wasmedge_quickjs.csv', index=False, header=False)
+
+
+
+
+'''
+import pandas as pd
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained("Xenova/gpt-4")
+
+tokenizer = GPT2TokenizerFast.from_pretrained('Xenova/gpt-4')
+
+
+df = pd.read_csv('/home/aru/Desktop/Github_analyser/Output/summary/eth_md_summary.csv')
+
+def count_words(text):
+    return len(text.split())
+
+def count_tokens(text):
+    tokens = tokenizer.encode(text)
+    return len(tokens)
+
+df['Content_Word_Count'] = df['Content'].apply(count_words)
+df['Summary_QnA_Word_Count'] = df['Summary and Q&A'].apply(count_words)
+
+df['Content_Token_Count'] = df['Content'].apply(count_tokens)
+df['Summary_QnA_Token_Count'] = df['Summary and Q&A'].apply(count_tokens)
+
+df.to_csv('output_file.csv', index=False)
+'''

scripts/Helper/local_csv.py

@@ -0,0 +1,31 @@
+import csv
+import os
+import sys
+
+csv.field_size_limit(10**9) 
+
+input_csv = r''
+output_csv = r''
+
+with open(input_csv, mode='r', newline='', encoding='utf-8') as infile, \
+     open(output_csv, mode='w', newline='', encoding='utf-8') as outfile:
+    
+    reader = csv.DictReader(infile)
+    writer = csv.writer(outfile)
+    
+    for row in reader:
+        path = row['Path']
+        content = row['Content']
+        extension = os.path.splitext(path)[1]
+        if extension == '.md':
+            new_content = f"The following is a markdown document located at {path}\n------\n{content}\n------"
+        elif extension == '.rs':
+            new_content = f"```rust:{path}\n{content}\n```"
+        elif extension == '.sh':
+            new_content = f"```bash:{path}\n{content}\n```"
+        elif extension == '.py':
+            new_content = f"```python:{path}\n{content}\n```"
+        else:
+            new_content = new_content = f"The following document is located at {path}\n------\n{content}\n------"
+        writer.writerow([new_content])
+print(f"Transformed CSV has been written to {output_csv}")

scripts/Summary/checkpoint.py

@@ -0,0 +1,196 @@
+import openai
+import csv
+import os
+import json
+import time
+from datetime import datetime
+csv.field_size_limit(10**9)
+
+API_BASE_URL = "https://llama.us.gaianet.network/v1"
+MODEL_NAME = "llama"
+API_KEY = "GAIA"
+
+def save_checkpoint(checkpoint_file, processed_row, processed_contents):
+    checkpoint_data = {
+        'last_processed_row': processed_row,
+        'processed_contents': list(processed_contents)
+    }
+    with open(checkpoint_file, 'w') as f:
+        json.dump(checkpoint_data, f)
+
+def load_checkpoint(checkpoint_file):
+    if os.path.exists(checkpoint_file):
+        with open(checkpoint_file, 'r') as f:
+            checkpoint_data = json.load(f)
+            return (
+                checkpoint_data['last_processed_row'],
+                set(checkpoint_data['processed_contents'])
+            )
+    return 0, set()
+
+def create_backup(file_path):
+    """Create a backup of the output file with timestamp"""
+    if os.path.exists(file_path):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = f"{file_path}.{timestamp}.bak"
+        os.rename(file_path, backup_path)
+        print(f"Created backup at: {backup_path}")
+
+def summarize(source_text, max_retries=3):
+    for attempt in range(max_retries):
+        try:
+            client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+            chat_completion = client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": """
+                        You are an AI assistant designed to review pull requests (PRs) in GitHub repositories. Your task is to:
+
+                        1. Summarize Code-related Files:
+                        - Focus on key changes in the code, including additions, deletions, and modifications.
+                        - Capture essential details such as the purpose of the code, any new functions, classes, or methods, and the overall impact of these changes on the project.
+                        - Highlight any dependencies, error handling, or performance implications.
+
+                        2. Summarize Markdown Files:
+                        - Extract key points from documentation, readme files, and other markdown content.
+                        - Identify sections related to project setup, usage instructions, change logs, or contributor guidelines.
+                        - Note updates in the documentation and the implications for users or developers.
+                        """,
+                    },
+                    {
+                        "role": "user",
+                        "content": source_text,
+                    }
+                ],
+                model=MODEL_NAME,
+                stream=False,
+            )
+            return chat_completion.choices[0].message.content
+        except Exception as e:
+            if attempt == max_retries - 1:
+                raise
+            print(f"Attempt {attempt + 1} failed: {str(e)}. Retrying...")
+            time.sleep(2 ** attempt)  
+
+def qgen(source_text, max_retries=3):
+    for attempt in range(max_retries):
+        try:
+            client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+            chat_completion = client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "Respond with a list of 10 questions. The text in the user message must contain specific answers to each question. Each question must be on its own line. Just list the questions without any introductory text or numbers.",
+                    },
+                    {
+                        "role": "user",
+                        "content": source_text,
+                    }
+                ],
+                model=MODEL_NAME,
+                stream=False,
+            )
+            return chat_completion.choices[0].message.content
+        except Exception as e:
+            if attempt == max_retries - 1:
+                raise
+            print(f"Attempt {attempt + 1} failed: {str(e)}. Retrying...")
+            time.sleep(2 ** attempt)
+
+def agen(source_text, question, max_retries=3):
+    for attempt in range(max_retries):
+        try:
+            client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+            chat_completion = client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "Give a comprehensive and well-reasoned answer to the user question strictly based on the context below and try to give a detailed explanation while answering the questions. Also try to add some bonus tip to in each answer and some relevant example outside of the content.\n" + source_text
+                    },
+                    {
+                        "role": "user",
+                        "content": question,
+                    }
+                ],
+                model=MODEL_NAME,
+                stream=False,
+            )
+            return chat_completion.choices[0].message.content
+        except Exception as e:
+            if attempt == max_retries - 1:
+                raise
+            print(f"Attempt {attempt + 1} failed: {str(e)}. Retrying...")
+            time.sleep(2 ** attempt)
+
+def main():
+    input_path = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\output\local_repo\docs\quick_js_js.csv"
+    output_path = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\output\local_repo\summary\quick_js_js.csv"
+    checkpoint_file = output_path + '.checkpoint'
+    
+    last_processed_row, processed_contents = load_checkpoint(checkpoint_file)
+    
+    if last_processed_row == 0 and os.path.exists(output_path):
+        create_backup(output_path)
+
+    row_count = last_processed_row
+
+    try:
+        with open(input_path, 'r', newline='', encoding='utf-8') as infile, \
+             open(output_path, 'a', newline='', encoding='utf-8') as outfile:
+
+            csv_reader = csv.reader(infile)
+            csv_writer = csv.writer(outfile)
+            
+            for _ in range(last_processed_row):
+                next(csv_reader)
+
+            for row in csv_reader:
+                try:
+                    main_content = row[0]
+
+                    if main_content in processed_contents:
+                        continue
+
+                    print(f"Processing row {row_count + 1}...")
+                    
+                    summary = summarize(main_content)
+                    qs = qgen(main_content)
+                    qna_list = []
+                    
+                    for q in qs.splitlines():
+                        if len(q.strip()) == 0:
+                            continue
+                        answer = agen(main_content, q)
+                        qna_list.append(f"Q: {q}\nA: {answer}")
+
+                    csv_writer.writerow([main_content, f"Summary:\n{summary}"])
+                    for qna in qna_list:
+                        csv_writer.writerow([main_content, qna])
+                    
+                    processed_contents.add(main_content)
+                    row_count += 1
+
+                    save_checkpoint(checkpoint_file, row_count, processed_contents)
+                    
+                    print(f"Successfully processed row {row_count}")
+
+                except Exception as e:
+                    print(f"Error processing row {row_count + 1}: {str(e)}")
+                    # Save checkpoint before raising the error
+                    save_checkpoint(checkpoint_file, row_count, processed_contents)
+                    raise
+
+        print(f"Processing completed. Modified data has been written to {output_path}")
+        print(f"Total rows processed: {row_count}")
+        
+        if os.path.exists(checkpoint_file):
+            os.remove(checkpoint_file)
+
+    except Exception as e:
+        print(f"An error occurred: {str(e)}")
+        print(f"Progress has been saved. You can resume from row {row_count + 1}")
+        raise
+
+if __name__ == "__main__":
+    main()

scripts/Summary/qna_only.py

@@ -0,0 +1,120 @@
+import openai
+import csv
+import sys
+import os
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+API_BASE_URL = "https://llama.us.gaianet.network/v1"
+MODEL_NAME = "llama"
+API_KEY = "GAIA"
+
+client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
+def qgen(source_text):
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": "Respond with a list of 10 questions. The text in the user message must contain specific answers to each question. Each question must be complete without references to unclear context such as 'this team' or 'that lab'. Each question must be on its own line. Just list the questions without any introductory text or numbers.",
+                },
+                {
+                    "role": "user",
+                    "content": source_text,
+                }
+            ],
+            model=MODEL_NAME,
+            stream=False,
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as e:
+        logging.error(f"Error in generating questions: {e}")
+        return None
+
+def agen(source_text, question):
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": "Give a comprehensive and well-reasoned answer to the user question strictly based on the context below.\n" + source_text,
+                },
+                {
+                    "role": "user",
+                    "content": question,
+                }
+            ],
+            model=MODEL_NAME,
+            stream=False,
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as e:
+        logging.error(f"Error in generating answer: {e}")
+        return None
+
+def process_csv(input_csv, output_csv):
+    results = []
+    processed_contents = set()
+
+    if os.path.exists(output_csv):
+        with open(output_csv, 'r', newline='', encoding='utf-8') as outfile:
+            reader = csv.reader(outfile)
+            for row in reader:
+                processed_contents.add(row[0]) 
+
+    try:
+        with open(input_csv, 'r', newline='', encoding='utf-8') as csvfile_in, \
+             open(output_csv, 'a', newline='', encoding='utf-8') as csvfile_out:
+
+            csv_reader = csv.DictReader(csvfile_in)
+            fieldnames = ['Content', 'Summary and Q&A']
+            writer = csv.DictWriter(csvfile_out, fieldnames=fieldnames)
+
+            if not os.path.exists(output_csv) or os.stat(output_csv).st_size == 0:
+                writer.writeheader()  
+
+            for row in csv_reader:
+                main_content = row['Content']
+                summary = row['Summary']
+
+                if main_content in processed_contents:
+                    logging.info(f"Skipping already processed content: {main_content}")
+                    continue
+
+                questions = qgen(main_content)
+                if questions is None:
+                    logging.error(f"Skipping content due to question generation failure: {main_content}")
+                    continue
+
+                question_list = questions.splitlines()
+                result = [{"Content": main_content, "Summary and Q&A": f"Summary:\n{summary}"}]
+                
+                for question in question_list:
+                    if len(question.strip()) == 0:
+                        continue
+                    answer = agen(main_content, question)
+                    if answer is None:
+                        logging.error(f"Skipping question due to answer generation failure: {question}")
+                        continue
+                    result.append({"Content": main_content, "Summary and Q&A": f"Q: {question}\nA: {answer}"})
+
+                for res in result:
+                    writer.writerow(res)
+                    csvfile_out.flush() 
+
+                logging.info(f"Processed and saved content: {main_content}")
+
+    except Exception as e:
+        logging.error(f"Error processing CSV: {e}")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        logging.error("Usage: python script.py <input_csv> <output_csv>")
+        sys.exit(1)
+
+    input_csv_file = sys.argv[1]
+    output_csv_file = sys.argv[2]
+
+    process_csv(input_csv_file, output_csv_file)

scripts/Summary/readme.md

@@ -0,0 +1,9 @@
+1. code_summarizer.py takes input from output folder a csv that has path and content as summarizes it and create a new csv containing content and summary as headers.
+
+2. qna.py generates a new summary file from the above summary file that can be used to generate multiple vector embeddings from 1 file only.
+
+3. openai_summary.py combines the above 2 step and directly generates the summary file from the raw CSV file but it uses openai api.
+
+4. final_split_summary.py also does the similar function but it uses gaianet endpoints instead of openai api.
+
+The key difference between the above 2 files is the use of APIs from open source models and proprietary models.

scripts/Summary/summarizer(openai).py

@@ -0,0 +1,116 @@
+import csv
+import os
+import openai
+from openai import OpenAI
+client = OpenAI(api_key='')
+MODEL_NAME = "gpt-4o"
+
+def summarize(source_text):
+    chat_completion = client.chat.completions.create(model=MODEL_NAME,
+    messages=[
+        {
+            "role": "system",
+            "content": """
+            You are an AI assistant designed to review pull requests (PRs) in GitHub repositories. Your task is to:
+
+            1. Summarize Code-related Files:
+             - Focus on key changes in the code, including additions, deletions, and modifications.
+             - Capture essential details such as the purpose of the code, any new functions, classes, or methods, and the overall impact of these changes on the project.
+             - Highlight any dependencies, error handling, or performance implications.
+
+            2. Summarize Markdown Files:
+            - Extract key points from documentation, readme files, and other markdown content.
+            - Identify sections related to project setup, usage instructions, change logs, or contributor guidelines.
+            - Note updates in the documentation and the implications for users or developers.
+""",
+        },
+        {
+            "role": "user",
+            "content": source_text,
+        }
+    ])
+    return chat_completion.choices[0].message.content
+
+def qgen(source_text):
+    chat_completion = client.chat.completions.create(model=MODEL_NAME,
+    messages=[
+        {
+            "role": "system",
+            "content": "Respond with a list of 10 questions. The text in the user message must contain specific answers to each question. Each question must be on its own line. Just list the questions without any introductory text or numbers.",
+        },
+        {
+            "role": "user",
+            "content": source_text,
+        }
+    ])
+    return chat_completion.choices[0].message.content
+
+def agen(source_text, question):
+    chat_completion = client.chat.completions.create(model=MODEL_NAME,
+    messages=[
+        {
+            "role": "system",
+            "content": (
+                "Give a comprehensive and well-reasoned answer to the user question strictly based on the context below "
+                "and try to give a detailed explanation while answering the questions. Also try to add some bonus tip to "
+                "each answer and some relevant example outside of the content.\n\nContext:\n" + source_text
+            ),
+        },
+        {
+            "role": "user",
+            "content": question,
+        }
+    ])
+    return chat_completion.choices[0].message.content
+
+def main():
+    input_path = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\Output\main_repos\gaianet_md_2.csv"
+    output_path = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\Output\split_summary\gaianet_md_open_new.csv"
+    processed_contents = set()
+    output_file_exists = os.path.exists(output_path)
+
+    if output_file_exists:
+        with open(output_path, 'r', newline='', encoding='utf-8') as csvfile:
+            csv_reader = csv.DictReader(csvfile)
+            for row in csv_reader:
+                processed_contents.add(row['Content'])
+
+    row_count = 0
+
+    with open(input_path, 'r', newline='', encoding='utf-8') as csvfile_in, \
+         open(output_path, 'a', newline='', encoding='utf-8') as csvfile_out:
+
+        csv_reader = csv.DictReader(csvfile_in)
+        fieldnames = ["Content", "Summary and Q&A"]
+        writer = csv.DictWriter(csvfile_out, fieldnames=fieldnames)
+
+        if not output_file_exists:
+            writer.writeheader()
+
+        for row in csv_reader:
+            main_content = row['Content']
+
+            if main_content in processed_contents:
+                continue
+
+            summary = summarize(main_content)
+            qs = qgen(main_content)
+
+            if summary.strip():
+                writer.writerow({"Content": main_content, "Summary and Q&A": f"Summary:\n{summary}"})
+
+            for q in qs.strip().split('\n'):
+                if q.strip():
+                    answer = agen(main_content, q)
+                    if answer.strip():
+                        writer.writerow({"Content": main_content, "Summary and Q&A": f"Q: {q}\nA: {answer}"})
+
+            processed_contents.add(main_content)
+            row_count += 1
+            print(f"Processed row {row_count}")
+
+    print(f"Modified data has been written to {output_path}")
+    print(f"Total rows summarized: {row_count}")
+
+if __name__ == "__main__":
+    main()

scripts/Summary/summarizer.py

@@ -0,0 +1,135 @@
+import openai
+import csv
+import os
+import time
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+csv.field_size_limit(10**9)
+
+API_BASE_URL = "https://llama.us.gaianet.network/v1"
+MODEL_NAME = "llama"
+API_KEY = "GAIA"
+
+def create_retry_decorator():
+    return retry(
+        retry=retry_if_exception_type((openai.APIError, openai.APITimeoutError)),
+        stop=stop_after_attempt(3), 
+        wait=wait_exponential(multiplier=1, min=4, max=10),
+        before_sleep=lambda retry_state: print(f"Retry attempt {retry_state.attempt_number} after {retry_state.outcome.exception()}")
+    )
+
+@create_retry_decorator()
+def make_api_call(client, messages, model):
+    return client.chat.completions.create(
+        messages=messages,
+        model=model,
+        stream=False,
+    )
+
+def summarize(source_text):
+    client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    messages = [
+        {
+            "role": "system",
+            "content": """
+            You are an AI assistant designed to review pull requests (PRs) in GitHub repositories. Your task is to:
+
+            1. Summarize Code-related Files:
+            - Focus on key changes in the code, including additions, deletions, and modifications.
+            - Capture essential details such as the purpose of the code, any new functions, classes, or methods, and the overall impact of these changes on the project.
+            - Highlight any dependencies, error handling, or performance implications.
+
+            2. Summarize Markdown Files:
+            - Extract key points from documentation, readme files, and other markdown content.
+            - Identify sections related to project setup, usage instructions, change logs, or contributor guidelines.
+            - Note updates in the documentation and the implications for users or developers.
+            """,
+        },
+        {
+            "role": "user",
+            "content": source_text,
+        }
+    ]
+    chat_completion = make_api_call(client, messages, MODEL_NAME)
+    return chat_completion.choices[0].message.content
+
+def qgen(source_text):
+    client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    messages = [
+        {
+            "role": "system",
+            "content": "Respond with a list of 10 questions. The text in the user message must contain specific answers to each question. Each question must be on its own line. Just list the questions without any introductory text or numbers.",
+        },
+        {
+            "role": "user",
+            "content": source_text,
+        }
+    ]
+    chat_completion = make_api_call(client, messages, MODEL_NAME)
+    return chat_completion.choices[0].message.content
+
+def agen(source_text, question):
+    client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    messages = [
+        {
+            "role": "system",
+            "content": "Give a comprehensive and well-reasoned answer to the user question strictly based on the context below and try to give a detailed explanation while answering the questions. Also try to add some bonus tip to in each answer and some relevant example outside of the content.\n" + source_text
+        },
+        {
+            "role": "user",
+            "content": question,
+        }
+    ]
+    chat_completion = make_api_call(client, messages, MODEL_NAME)
+    return chat_completion.choices[0].message.content
+
+def main():
+    input_path = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\output\local_repo\docs\wasmedge_docs.csv"
+    output_path = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\output\local_repo\summary\wasmedge_docs_2.csv"
+    processed_contents = set()
+    output_file_exists = os.path.exists(output_path)
+
+    row_count = 0
+
+    with open(input_path, 'r', newline='', encoding='utf-8') as infile, \
+         open(output_path, 'a', newline='', encoding='utf-8') as outfile:
+
+        csv_reader = csv.reader(infile)
+        csv_writer = csv.writer(outfile)
+
+        if not output_file_exists:
+            pass 
+
+        for row in csv_reader:
+            try:
+                main_content = row[0]
+
+                if main_content in processed_contents:
+                    continue  
+
+                summary = summarize(main_content)
+                qs = qgen(main_content)
+                qna_list = []
+                for q in qs.splitlines():
+                    if len(q.strip()) == 0:
+                        continue
+                    answer = agen(main_content, q)
+                    qna_list.append(f"Q: {q}\nA: {answer}")
+
+                csv_writer.writerow([main_content, f"Summary:\n{summary}"])
+                for qna in qna_list:
+                    csv_writer.writerow([main_content, qna])
+                
+                processed_contents.add(main_content)
+
+                row_count += 1
+                print(f"Processed row {row_count}")
+
+            except Exception as e:
+                print(f"Error processing row {row_count + 1}: {str(e)}")
+                continue
+
+    print(f"Modified data has been written to {output_path}")
+    print(f"Total rows summarized: {row_count}")
+
+if __name__ == "__main__":
+    main()

scripts/Summary/summarizer_old.py

@@ -0,0 +1,127 @@
+import openai
+import csv
+import os
+
+API_BASE_URL = "https://llama.us.gaianet.network/v1"
+MODEL_NAME = "llama"
+API_KEY = "GAIA"
+
+def summarize(source_text):
+    client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "system",
+                "content": """
+            You are an AI assistant designed to review pull requests (PRs) in GitHub repositories. Your task is to:
+
+            1. Summarize Code-related Files:
+             - Focus on key changes in the code, including additions, deletions, and modifications.
+             - Capture essential details such as the purpose of the code, any new functions, classes, or methods, and the overall impact of these changes on the project.
+             - Highlight any dependencies, error handling, or performance implications.
+
+            2. Summarize Markdown Files:
+            - Extract key points from documentation, readme files, and other markdown content.
+            - Identify sections related to project setup, usage instructions, change logs, or contributor guidelines.
+            - Note updates in the documentation and the implications for users or developers.
+            """,
+            },
+            {
+                "role": "user",
+                "content": source_text,
+            }
+        ],
+        model=MODEL_NAME,
+        stream=False,
+    )
+    return chat_completion.choices[0].message.content
+
+def qgen(source_text):
+    client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "system",
+                "content": "Respond with a list of 10 questions. The text in the user message must contain specific answers to each question. Each question must be on its own line. Just list the questions without any introductory text or numbers.",
+            },
+            {
+                "role": "user",
+                "content": source_text,
+            }
+        ],
+        model=MODEL_NAME,
+        stream=False,
+    )
+    return chat_completion.choices[0].message.content
+
+def agen(source_text, question):
+    client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "system",
+                "content": "Give a comprehensive and well-reasoned answer to the user question strictly based on the context below and try to give a detailed explanation while answering the questions. Also try to add some bonus tip to in each answer and some relevant example outside of the content.\n" + source_text},
+            {
+                "role": "user",
+                "content": question,
+            }
+        ],
+        model=MODEL_NAME,
+        stream=False,
+    )
+    return chat_completion.choices[0].message.content
+
+def main():
+    input_path = r"C:\Users\91745\OneDrive\Desktop\Github_analyser\output\main_repos\2.llamaedge_all.csv"
+    output_path = "test_old.csv"
+    processed_contents = set()
+    output_file_exists = os.path.exists(output_path)
+    if output_file_exists:
+        with open(output_path, 'r', newline='', encoding='utf-8') as csvfile:
+            csv_reader = csv.DictReader(csvfile)
+            for row in csv_reader:
+                processed_contents.add(row['Content'])
+    else:
+        pass
+
+    row_count = 0
+
+    with open(input_path, 'r', newline='', encoding='utf-8') as csvfile_in, \
+         open(output_path, 'a', newline='', encoding='utf-8') as csvfile_out:
+
+        csv_reader = csv.DictReader(csvfile_in)
+        fieldnames = ["Content", "Summary and Q&A"]
+        writer = csv.DictWriter(csvfile_out, fieldnames=fieldnames)
+
+        if not output_file_exists:
+            writer.writeheader()
+
+        for row in csv_reader:
+            main_content = row['Content']
+            if main_content in processed_contents:
+                continue  
+
+            if len(main_content.split()) > 5000:
+                continue  
+            summary = summarize(main_content)
+            qs = qgen(main_content)
+            qna_list = []
+            for q in qs.splitlines():
+                if len(q.strip()) == 0:
+                    continue
+                answer = agen(main_content, q)
+                qna_list.append(f"Q: {q}\nA: {answer}")
+
+            writer.writerow({"Content": main_content, "Summary and Q&A": f"Summary:\n{summary}"})
+            for qna in qna_list:
+                writer.writerow({"Content": main_content, "Summary and Q&A": qna})
+            processed_contents.add(main_content)
+
+            row_count += 1
+            print(f"Processed row {row_count}")
+
+    print(f"Modified data has been written to {output_path}")
+    print(f"Total rows summarized: {row_count}")
+
+if __name__ == "__main__":
+    main()

scripts/Summary/summary_only.py

@@ -0,0 +1,56 @@
+import pandas as pd
+import openai
+import logging
+import time
+
+logging.basicConfig(level=logging.INFO)
+
+API_BASE_URL = "https://llama.us.gaianet.network/v1"
+MODEL_NAME = "llama"
+API_KEY = "GAIA"
+
+client = openai.OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
+def summarize_code(code, path):
+    try:
+        start_time = time.time()
+        response = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are an expert software engineer. Your task is to analyze the provided code and generate a concise, coherent summary that captures the purpose, functionality, and key components of the code. Additionally, highlight any potential issues or areas for improvement."
+                },
+                {
+                    "role": "user",
+                    "content": f"Code from {path}:\n\n{code}",
+                }
+            ],
+            model=MODEL_NAME,
+            stream=False,
+        )
+        logging.info(f"API call took {time.time() - start_time} seconds.")
+        return response.choices[0].message.content
+    except Exception as e:
+        logging.error(f"Error in summarizing code: {e}")
+        return "Error: Could not summarize"
+    
+
+def summarize_csv_content(input_csv_file, output_csv_file):
+    try:
+        df = pd.read_csv(input_csv_file)
+        if 'Content' not in df.columns or 'Path' not in df.columns:
+            raise ValueError("'Content' or 'Path' column not found in the input CSV file.")
+
+        logging.info("Starting summarization...")
+        df['Summary'] = df.apply(lambda row: summarize_code(row['Content'], row['Path']) if pd.notnull(row['Content']) else "", axis=1)
+
+        df.to_csv(output_csv_file, index=False)
+        logging.info(f"Summaries have been generated and saved to {output_csv_file}")
+    except Exception as e:
+        logging.error(f"Error processing CSV: {e}")
+
+if __name__ == "__main__":
+    input_csv_file = '/home/aru/Desktop/Github_analyser/Output/main_repos/wasmedge_shorten.csv'  
+    output_csv_file = '/home/aru/Desktop/Github_analyser/Output/summary/wasmedge_summary.csv' 
+
+    summarize_csv_content(input_csv_file, output_csv_file)

scripts/readme.md

@@ -0,0 +1,3 @@
+1. The first step is to see various file types inside the repo.
+2. The next step is to fetch data from these files using Python and various OCR methods for images and PDFs.
+3. The third step is to pre-process this data (if needed) and generate summaries or Questions and Answers from the data.

scripts/upload.py

@@ -0,0 +1,8 @@
+from huggingface_hub import HfApi
+api = HfApi()
+
+api.upload_folder(
+    folder_path=r"C:\Users\91745\OneDrive\Desktop\Github_analyser",
+    repo_id="FiendHunter/Github_bot_scripts",
+    repo_type="dataset",
+)