Added modules

graphs/graph_utils.py

@@ -0,0 +1,23 @@
+def format_graph_context(func_summaries, call_graph=None, class_hierarchy=None):
+    """
+    Format function summaries and graph information into a readable structured input.
+    """
+    lines = ["You are summarizing a Python module."]
+
+    if func_summaries:
+        lines.append("Function Summaries:")
+        for name, summary in func_summaries.items():
+            lines.append(f"- {name}: {summary}")
+
+    if call_graph:
+        lines.append("\nCall Graph:")
+        for caller, callees in call_graph.items():
+            if callees:
+                lines.append(f"- {caller} → {', '.join(callees)}")
+
+    if class_hierarchy:
+        lines.append("\nClass Hierarchy:")
+        for cls, methods in class_hierarchy.items():
+            lines.append(f"- {cls}: [{', '.join(methods)}]")
+
+    return "\n".join(lines)

models/models.py

@@ -0,0 +1,28 @@
+import torch
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+from sentence_transformers import SentenceTransformer
+
+device = 0 if torch.cuda.is_available() else -1
+
+tokenizer = AutoTokenizer.from_pretrained("Salesforce/codet5-base-multi-sum")
+model = AutoModelForSeq2SeqLM.from_pretrained("Salesforce/codet5-base-multi-sum")
+
+func_summarizer = pipeline(
+    "text2text-generation",
+    model=model,
+    tokenizer=tokenizer,
+    device=device,
+    batch_size=8,
+)
+
+embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+file_summarizer = pipeline(
+    "summarization",
+    model="allenai/led-base-16384",
+    tokenizer="allenai/led-base-16384",
+    device=device,
+    truncation=True,
+    max_length=128,
+    min_length=64,
+)

parsers/parsers.py

@@ -0,0 +1,39 @@
+import ast
+
+def extract_functions_from_code(code: str):
+    try:
+        tree = ast.parse(code)
+        return {
+            node.name: ast.get_source_segment(code, node)
+            for node in ast.walk(tree)
+            if isinstance(node, ast.FunctionDef)
+        }
+    except:
+        return {}
+
+def extract_call_graph(code: str):
+    call_graph = {}
+    try:
+        tree = ast.parse(code)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                callers = []
+                for child in ast.walk(node):
+                    if isinstance(child, ast.Call) and hasattr(child.func, "id"):
+                        callers.append(child.func.id)
+                call_graph[node.name] = list(set(callers))
+    except:
+        pass
+    return call_graph
+
+def extract_class_hierarchy(code: str):
+    class_map = {}
+    try:
+        tree = ast.parse(code)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                methods = [n.name for n in node.body if isinstance(n, ast.FunctionDef)]
+                class_map[node.name] = methods
+    except:
+        pass
+    return class_map

summarizers/file_summarizers.py

@@ -0,0 +1,44 @@
+from parsers.parsers import extract_functions_from_code, extract_call_graph, extract_class_hierarchy
+from graphs.graph_utils import format_graph_context
+from models.models import func_summarizer, file_summarizer
+
+def summarize_file_with_graph(code_text: str, top_k: int = 5):
+    """
+    Summarize a file by:
+    - Extracting function-level summaries using CodeT5
+    - Building call/class hierarchy (graph_utils)
+    - Creating structured prompt for LED summarizer
+    """
+    functions = extract_functions_from_code(code_text)
+    if not functions:
+        return "No functions found."
+
+    func_names = list(functions.keys())
+    func_bodies = list(functions.values())
+
+    # Summarize functions
+    func_summaries_raw = func_summarizer(func_bodies, max_length=64, do_sample=False)
+    func_summaries = {
+        func_names[i]: func_summaries_raw[i]["generated_text"].strip()
+        for i in range(len(func_names))
+    }
+
+    # Select top-k longest functions as proxy for importance
+    top_funcs = sorted(func_summaries.items(), key=lambda x: len(functions[x[0]]), reverse=True)[:top_k]
+    top_func_summaries = {k: v for k, v in top_funcs}
+
+    # Build graph context
+    call_graph = extract_call_graph(code_text)
+    class_hierarchy = extract_class_hierarchy(code_text)
+    input_text = format_graph_context(top_func_summaries, call_graph, class_hierarchy)
+
+    # Summarize with LED
+    summary = file_summarizer(
+        input_text,
+        max_length=128,
+        min_length=64,
+        no_repeat_ngram_size=3,
+        do_sample=False,
+    )[0]["summary_text"]
+
+    return summary

summarizers/repo_summarizers.py

@@ -0,0 +1,67 @@
+from summarizers.file_summarizers import summarize_file_with_graph
+from models.models import file_summarizer
+
+def summarize_repo_with_graph(file_dict: dict, top_files=5, top_k_funcs=5):
+    """
+    Summarize a repository:
+    - Summarize each file using summarize_file_with_graph
+    - Combine top-k summaries
+    - Feed to LED summarizer
+    """
+    file_summaries = []
+
+    for file_path, code_text in list(file_dict.items())[:top_files]:
+        try:
+            summary = summarize_file_with_graph(code_text, top_k=top_k_funcs)
+            file_summaries.append(summary)
+        except Exception as e:
+            print(f"Skipped file {file_path} due to: {e}")
+
+    if not file_summaries:
+        return "No valid summaries found."
+
+    combined_input = "\n\n".join(file_summaries)
+    final_summary = file_summarizer(
+        combined_input,
+        max_length=256,
+        min_length=100,
+        no_repeat_ngram_size=3,
+        do_sample=False,
+    )[0]["summary_text"]
+
+    return final_summary
+
+# from transformers import AutoTokenizer
+
+# # reuse the same tokenizer instance you already loaded
+# tokenizer = file_summarizer.tokenizer
+
+# def summarize_repo_with_graph(file_dict: dict, top_files=5, top_k_funcs=5):
+#     file_summaries = []
+
+#     for file_path, code_text in list(file_dict.items())[:top_files]:
+#         try:
+#             summary = summarize_file_with_graph(code_text, top_k=top_k_funcs)
+#             file_summaries.append(summary)
+#         except Exception as e:
+#             print(f"Skipped file {file_path} due to: {e}")
+
+#     if not file_summaries:
+#         return "No valid summaries found."
+
+#     combined_input = "\n\n".join(file_summaries)
+
+#     # dynamic length cap
+#     tokens = tokenizer.encode(combined_input, truncation=False)
+#     suggested_max = min(256, max(100, len(tokens) // 2))
+#     suggested_min = min(100, suggested_max - 20)
+
+#     final_summary = file_summarizer(
+#         combined_input,
+#         max_length=suggested_max,
+#         min_length=suggested_min,
+#         no_repeat_ngram_size=3,
+#         do_sample=False,
+#     )[0]["summary_text"]
+
+#     return final_summary