added more features

app.py

@@ -1,4 +1,5 @@
 import streamlit as st
+import time
 from handler import *
 
 def main():
@@ -18,16 +19,29 @@ def main():
   with col2:
     # Radio buttons for analysis type
     analysis_type = st.radio("Choose analysis type:", 
-                                ("Code review", "Code refinement", "Unit tests"))
+                                ("Code review", "Code refinement","Documentation", "Unit tests"))
 
   # Submit button
   if st.button("Submit"):
     # Process the code and prompt based on analysis_type (implementation omitted for brevity)
     if analysis_type == "Code review":
-      res=code_review(code, prompt)
+      res=review_code(code, prompt)
       #st.text_area(label="Result",value=res, height=300)
       st.markdown(res)
-    st.success(f"Code analysis for {analysis_type} submitted successfully!")
+      time.sleep(1)
+      #st.markdown("Hello ooo")
+
+    elif analysis_type == "Code refinement":
+      res=refine_code(code, prompt)
+      #st.text_area(label="Result",value=res, height=300)
+      st.markdown(res)
+
+    elif analysis_type == "Documentation":
+      res=generate_documentation(code, prompt)
+      #st.text_area(label="Result",value=res, height=300)
+      st.markdown(res)
+  
+    st.success(f"Code analysis for {analysis_type} submitted successfully!")  
 
 if __name__ == "__main__":
   main()

gemini.py

@@ -7,8 +7,8 @@ generation_config=genai.types.GenerationConfig(
         # Only one candidate for now.
         #candidate_count=1,
         #stop_sequences=['x'],
-        #max_output_tokens=1024,
-        temperature=1.0
+        max_output_tokens=4096,
+        temperature=0.1
 )
 class GeminiModel:
     """
@@ -35,7 +35,11 @@ class GeminiModel:
     def execute(self, prompt: str) -> str:
         
         try:
-            response = self.model.generate_content(prompt, generation_config=None)
+            total_tokens = self.model.count_tokens(prompt).total_tokens
+            print(f"Input tokens: {total_tokens}")
+            response = self.model.generate_content(prompt, generation_config=generation_config)
+            output_tokens = self.model.count_tokens(response.text).total_tokens
+            print(f"Output tokens: {output_tokens}")
             return response.text
         except Exception as e:
             return f"An error occurred: {e}"

handler.py

@@ -1,19 +1,62 @@
-from gemini import GeminiModel
+import gemini
 from prompts import *
 
+def review_code(code, c_prompt=None):
+    if code is None or len(code) < 5 or code.isspace():
+        raise InvalidCodeException("No code provided")
 
-def code_review(code,c_prompt=None):
+    if c_prompt is not None and len(c_prompt) > 30:
+        prompt = custom_review_prompt(code.strip(), c_prompt.strip())
+    else:
+        #prompt = validation_prompt(code.strip())
+        prompt = default_review_prompt1(code.strip())
+
+    model = gemini.GeminiModel()
+    try:
+        res = model.execute(prompt)
+    except Exception as e:
+        raise CodeReviewException(str(e))
+
+    return res
+
+def refine_code(code, c_prompt=None):
+    if code is None or len(code) < 5 or code.isspace():
+        raise InvalidCodeException("No code provided")
 
-    if code is None or len(code)< 5 or code.isspace():
-        return "No Code Provided"
-    
     if c_prompt is not None and len(c_prompt) > 30:
-        prompt=custom_prompt(code.strip(),c_prompt.strip())
+        prompt = custom_review_prompt(code.strip(), c_prompt.strip())
     else:
-        prompt=default_gemini_prompt(code.strip())
-    
-    
-    model=GeminiModel()    
-    res= model.execute(prompt)
+        #prompt = validation_prompt(code.strip())
+        prompt = default_refine_prompt(code.strip())
+
+    model = gemini.GeminiModel()
+    try:
+        res = model.execute(prompt)
+    except Exception as e:
+        raise CodeReviewException(str(e))
+
     return res
+
+def generate_documentation(code,c_prompt):
     
+    if code is None or len(code) < 5 or code.isspace():
+        raise InvalidCodeException("No code provided")
+
+    if c_prompt is not None and len(c_prompt) > 30:
+        prompt = custom_review_prompt(code.strip(), c_prompt.strip())
+    else:
+        prompt = default_doc_prompt(code.strip())
+
+    model = gemini.GeminiModel()
+    try:
+        res = model.execute(prompt)
+    except Exception as e:
+        raise CodeReviewException(str(e))
+
+    return res
+
+class InvalidCodeException(Exception):
+    pass
+
+class CodeReviewException(Exception):
+    pass

prompts.py

@@ -1,5 +1,7 @@
-TASK="As an experienced software developer responsible for code review and feedback, review the following python code by considering the best practices given in the guidelines below and provide your Observations and Suggestions."
-INSTRUCTIONS="""Take a deep breath before providing the feedback and thoroughly understand the code logic.
+ROLE="You are an experienced python software developer responsible for code review and feedback."
+TASK="Review the following python code by considering the best practices given in the guidelines below and provide your Observations and Suggestions."
+INSTRUCTIONS="""Identify the code. If no code is present then say 'No code given'.
+Take a deep breath before providing the feedback and thoroughly understand the code logic.
 Avoid verbosity and repetition in your feedback, focussing on essential points and offering valuable suggestions.
 Add your own observations and suggestions as needed, and only include comments that are neccessary for clarity and improvement.
 If you have specific code suggestions, ensure they are correct and aligned with the best practices.  
@@ -33,18 +35,18 @@ Race conditions have been handled
 Locks are acquired and released in the right order to prevent deadlocks, even in error handling code.
 All methods are commented in clear language
 """
-
+#First check whether the given input contains any code snippet or not.
 STEPS="""Follow the steps in the same order:
 1. Understand the code logic and structure.
-2. Notedown the observations based on the guodelines given above.
+2. Notedown the observations based on the guidelines given above.
 3. Give suggestions for improving the code.
 4. Give an example of Final improved code. 
 """
 
-def default_gemini_prompt(code, guidelines=None):
+def default_review_prompt1(code, guidelines=None):
     if guidelines is None:
         guidelines=GUIDELINES
-    prompt=f"""<Task>: {TASK}
+    prompt=f"""<Task>: {ROLE} {TASK}
     <Instructions>: {INSTRUCTIONS}
 
     <Guidelines>: {guidelines}
@@ -57,34 +59,126 @@ def default_gemini_prompt(code, guidelines=None):
     return prompt
 
 
-def prompt2(code):
-    prompt=f"""
-<task>: As an experienced software developer responsible for code review and feedback, review the following code by considering the best practices given in the guidelines below and provide your Observations and Suggestions
-Code: {code}
+def default_review_prompt2(code):
 
-The following custom guidelines should be considered during the review:
+    prompt=f"""<Task>: {ROLE} {TASK}
+    <Intsructions>: Analyze the provided code and identify the key components (classes, functions, modules).
+1. Analyze each key component following chain of thoughts. Consider the purpose of the component, its readability, efficiency, and adherence to the listed custom guidelines. 
+2. Break down your review into a step-by-step process, explaining your reasoning at each point. Maintain a clear and concise tone throughout the review.
+3. Add your own observations and suggestions as needed, and only include comments that are neccessary for clarity and improvement.
+4. Highlight serious violations.
+5. Give suggestions for improving the code.
+6. Give an example of Final improved code. 
 
-{GUIDELINES}
+    <Guidelines>: {GUIDELINES}
 
-Starting from the beginning of the code, analyze each line following a chain of thoughts. Consider the purpose of the code, its readability, efficiency, and adherence to the listed custom guidelines. 
+    <Steps to follow>: {STEPS}
 
-For each line, provide feedback that includes:
+    <code>: {code}
+    """
 
-* Whether the code achieves its intended purpose.
-* If there are any readability issues or areas for improvement.
-* Suggestions for optimization or alternative approaches (if applicable).
-* If there are any violations of the custom guidelines.
+    promptt=f"""
+<task>: {ROLE} Review the following code by considering the best practices given in the guidelines below.
+<Guidelines>: {GUIDELINES}
 
-Break down your review into a step-by-step process, explaining your reasoning at each point. Maintain a clear and concise tone throughout the review.
-Add your own observations and suggestions as needed, and only include comments that are neccessary for clarity and improvement.
-If you have specific code suggestions, ensure they are correct and aligned with the best practices
 
-**Overall Recommendation:**
 
-Based on your analysis, provide an overall recommendation for the code. This could be approval with minor suggestions, approval with moderate changes, or rejection with a clear explanation for required improvements.
+<Code>: {code}
 """
     
     return prompt
 
-def custom_prompt(c_prompt,code):
+def default_review_prompt3(code):
+    prompt= f"""Conduct a comprehensive code review of the provided Python script, focusing on its structure, functionality, and adherence to best practices.\
+        The script is designed to automate a specific task, and your review should assess its efficiency, readability, and maintainability.
+        
+    <Guidelines for the Code Review>:
+- Understand the script: Check whether the script contains a python script or not. 
+- Structure and Organization: Evaluate the script's overall structure and organization. Is the code logically divided into functions or sections? Are there any redundant or unnecessary sections?
+- Declare constants as applicable: Make sure constants are declared whenever applicable. 
+- Functionality and Correctness: Assess the script's functionality and correctness. Does it perform the intended task correctly? Are there any potential errors or edge cases that could cause issues?
+- Readability and Code Quality: Evaluate the script's readability and code quality. Are the variable names descriptive and consistent? Are there any unnecessary comments or redundant code?
+- Efficiency and Performance: Analyze the script's efficiency and performance. Are there any opportunities to optimize the code for better performance or reduce computational complexity?
+- Best Practices and Conventions: Check the script's adherence to best practices and coding conventions. Are there any deviations from standard Python coding conventions or best practices?
+- Error Handling and Debugging: Evaluate the script's error handling and debugging capabilities. Are there any try-except blocks or logging statements to handle potential errors?
+- Code Duplication and Redundancy: Identify any duplicated or redundant code sections. Are there any opportunities to refactor the code to reduce duplication?
+- Security and Vulnerabilities: Assess the script's security and potential vulnerabilities. Are there any sensitive data or user input handling that could lead to security issues?
+- Documentation and Comments: Evaluate the script's documentation and comments. Are there any clear and concise comments explaining the code's purpose and functionality?
+- Testing and Validation: Suggest any additional testing or validation steps to ensure the script's correctness and reliability.
+
+<Deliverables>:
+A detailed report summarizing the code review findings, including any suggestions for improvement.
+A revised version of the script incorporating the recommended changes and improvements.
+
+<Script>: {code} 
+    """
+
+    
+    return prompt
+
+
+def custom_review_prompt(c_prompt,code):
     return f'{c_prompt}\n<Code>: {code}'
+
+def default_refine_prompt(code):
+    prompt= f"""You are an expert software engineer and your task is to refine and optimize the code provided below while ensuring accuracy and functionality are maintained. 
+    Please follow the guidelines on best practices outlined to refine the code's efficiency and readability.
+
+<Guidelines on Best Practices>:
+- Use Intention-Revealing Names
+- Declare constants as applicable
+- Don't Repeat Yourself (Avoid Duplication)
+- Explain yourself in code
+- Make sure the code formatting is applied
+- Use Exceptions rather than Return codes
+- Don't return Null
+- Favor the use of standard exceptions
+- Don't ignore exceptions
+- Check parameters for validity
+- Return empty arrays or collections, not nulls
+- Minimize the accessibility of classes and members
+- In public classes, use accessor methods, not public fields
+- Minimize the scope of local variables
+- Refer to objects by their interfaces
+- Adhere to generally accepted naming conventions
+- Avoid finalizers
+- Synchronize access to shared mutable data
+- Valid unit test cases exist
+- Objects accessed by multiple threads are accessed only through a lock, or synchronized methods.
+- Race conditions have been handled
+- Locks are acquired and released in the right order to prevent deadlocks, even in error handling code.
+- All methods are commented in clear language
+- Use List Comprehension: Consider using list comprehension wherever possible.
+- Error Handling: Implement error handling to handle cases where the input is invalid.
+- Function Modularity: If possible, break down the code into smaller, more modular functions for better code organization.
+- Docstrings: Include clear and concise docstrings to describe the purpose of functions and any parameters they accept.
+- Variable Naming: Use descriptive variable names to improve code readability.
+- Efficient Algorithms: Opt for efficient algorithms and data structures to improve performance where possible.
+- Testing: Conduct thorough testing to ensure the optimized code produces the same results as the original.
+
+Your expertise in refining and optimizing this code will greatly enhance its efficiency and maintain its functionality. 
+
+<Deliverables>:
+A refined and optimized version of the code.
+
+<Code>: {code} 
+    """
+    
+    return prompt
+
+
+def default_doc_prompt(code):
+
+    
+    prompt= f""""For the following python code:\n{code}\n"
+            "Generate proper formal documentation." 
+            "The documentation should describe what the code does and explain the functionality."
+            "Include all details which should go in formal documentation"
+    """ 
+    return prompt
+
+def validation_prompt(code, guidelines=None):
+    prompt=f"""Check if the below input contains code snippets or not. Return only Yes or NO and nothing else.
+    Input: {code}
+"""
+    return prompt