Upload folder using huggingface_hub

.gradio/flagged/dataset1.csv

@@ -0,0 +1,79 @@
+Code Input,output,timestamp
+,,2026-03-05 21:52:00.985140
+"def find_duplicates(arr):
+    duplicates = []
+    for i in arr:
+        for j in arr:
+            if i == j:
+                duplicates.append(i)
+    return duplicates","# AI Code Review Arena
+
+## Reviewer
+### Bugs
+- The code will include the original items from the array as duplicates since it compares each element to itself.
+
+### Performance
+- The current implementation has a time complexity of O(n^2) due to the nested loops, which can be inefficient for large arrays.
+- Using a set for tracking seen elements would optimize the lookup time.
+
+### Readability
+- Variable names are clear but could be more descriptive (e.g., `duplicates` could be `found_duplicates`).
+- Consider using comments to explain the logic, especially for any non-obvious parts.
+
+### Security
+- The function seems secure, but consider input validation (e.g., checking if `arr` is indeed a list).
+- Evaluate handling of non-hashable types like lists within the input array, which may cause issues.
+
+---
+
+## Defender
+Thank you for your feedback! Let's address each point raised in your review to clarify my design decisions and consider valid concerns.
+
+### Bugs
+You're correct that, due to the nested loops, the current implementation will include the original items as duplicates. This is an oversight, as we should avoid comparing each element with itself. To fix this, we can simply adjust the condition to check if an element has already been seen. I appreciate you highlighting this, as handling duplicates accurately is critical to the function's purpose.
+
+### Performance
+You're spot-on regarding the time complexity of O(n^2). Although the nested loops make it easy to identify duplicates, they indeed become inefficient for large arrays. A more optimized approach using a set would greatly improve performance, reducing the complexity to O(n). This would allow for constant time complexity checks for existing elements, which is certainly worth implementing.
+
+### Readability
+I appreciate your comments about variable naming. While `duplicates` conveys the overall intention, a name like `found_duplicates` could provide clearer context. It's always beneficial to strive for clarity in code. Additionally, I acknowledge that adding comments can help explain the logic, especially for those who may not be familiar with this algorithm.
+
+### Security
+Regarding input validation, I agree that it's wise to ensure that `arr` is indeed a list to prevent runtime errors. Implementing type checking helps make the function more robust and user-friendly. Your point about handling non-hashable types like lists is also essential. I should consider implementing a strategy to either raise errors for unsupported types or handle them in a way that fits the function's purpose.
+
+### Conclusion
+In summary, your feedback has been invaluable. Addressing the bugs and performance issues will lead to a more efficient and accurate implementation. I'm in favor of improving readability and security through better naming, comments, and input validation. Thank you for your constructive criticism, and I'll revise the code accordingly! Would you like me to provide an updated version based on your feedback?
+
+---
+
+## Judge Verdict
+**Winner:** Review
+
+**Reason:** The review provided comprehensive points addressing key issues within the original code, specifically highlighting bugs, performance inefficiencies, readability, and security concerns. It effectively identified that the original implementation would falsely count elements as duplicates and pointed out the excessive time complexity due to nested loops. The defense acknowledged these issues but did not provide a concrete improvement plan or updated code to address them.
+
+**Suggested Fix:** 
+1. Replace the nested loops with a single pass using a set to track seen elements, ensuring that duplicates are captured correctly without counting each item itself.
+2. Implement input validation to ensure `arr` is a list and handle possible non-hashable types appropriately.
+3. Update variable naming for better clarity, e.g., change `duplicates` to `found_duplicates`, and add comments explaining the function’s logic.
+
+Here’s how a revised version of the code may look:
+
+```python
+def find_duplicates(arr):
+    if not isinstance(arr, list):
+        raise ValueError(""Input must be a list."")
+    
+    found_duplicates = []
+    seen = set()
+    
+    for item in arr:
+        if item in seen:
+            if item not in found_duplicates:  # Only add duplicates once
+                found_duplicates.append(item)
+        else:
+            seen.add(item)
+    
+    return found_duplicates
+```
+
+This version improves accuracy, efficiency, and clarity in accordance with the feedback provided.",2026-03-05 22:03:48.665872

README.md

@@ -1,12 +1,6 @@
 ---
-title: Code Review
-emoji: 🐢
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 6.8.0
+title: code_review
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.49.1
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,71 @@
+from agents import Runner
+import gradio as gr
+from dotenv import load_dotenv
+
+from reviewer_agent import reviewer
+from defender_agent import defender
+from judge_agent import judge
+
+load_dotenv(override=True)
+
+
+async def run_review(code: str):
+
+    if not code.strip():
+        return "Please paste some code."
+
+    # Reviewer
+    review_result = await Runner.run(
+        reviewer,
+        f"Review this code:\n\n{code}"
+    )
+    review = review_result.final_output
+
+    # Defender
+    defense_result = await Runner.run(
+        defender,
+        f"Code:{code}. Reviewer feedback: {review}.Respond to the reviewer."
+    )
+    defense = defense_result.final_output
+
+    # Judge
+    judge_result = await Runner.run(
+        judge,
+        f"Code: {code} Review: {review} Defense: {defense} Evaluate the debate and give a final verdict."
+    )
+    verdict = judge_result.final_output
+
+    return f"""
+# AI Code Review Arena
+
+## Reviewer
+{review}
+
+---
+
+## Defender
+{defense}
+
+---
+
+## Judge Verdict
+{verdict}
+"""
+
+
+demo = gr.Interface(
+    fn=run_review,
+    inputs=gr.Textbox(
+        lines=18,
+        placeholder="Paste your code here...",
+        label="Code Input"
+    ),
+    outputs=gr.Markdown(),
+    submit_btn="Run Review",
+    title="AI Code Review Arena",
+    description="Three AI agents debate your code: Reviewer → Defender → Judge."
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

defender_agent.py

@@ -0,0 +1,18 @@
+from agents import Agent
+
+
+instruction = """
+You are the developer who wrote the code.
+
+Your job:
+- explain design decisions
+- defend reasonable choices
+- accept valid criticism
+"""
+
+
+defender = Agent(
+        name="Code defender",
+        instructions=instruction,
+        model="gpt-4o-mini"
+)

judge_agent.py

@@ -0,0 +1,24 @@
+from agents import Agent
+
+
+instruction = """
+You are an impartial senior architect.
+
+Your task:
+1. Read the code
+2. Read the review
+3. Read the defense
+
+Then respond with:
+
+Winner:
+Reason:
+Suggested Fix:
+"""
+
+
+judge = Agent(
+        name="Judge",
+        instructions=instruction,
+        model="gpt-4o-mini"
+)

requirements.txt

@@ -0,0 +1,3 @@
+openai-agents
+gradio
+python-dotenv

reviewer_agent.py

@@ -0,0 +1,21 @@
+from agents import Agent
+
+
+instruction = """
+You are a senior software engineer performing a strict code review.
+
+Focus on:
+- bugs
+- performance
+- readability
+- security
+
+Respond with concise bullet points.
+"""
+
+
+reviewer = Agent(
+        name="Code reviewer",
+        instructions=instruction,
+        model="gpt-4o-mini"
+)