Revert "Repo settings file - fix a bug and apply to GitHub app"

Dockerfile.bitbucket_pipeline

@@ -0,0 +1,18 @@
+FROM python:3.10 as base
+
+ENV OPENAI_API_KEY=${OPENAI_API_KEY} \
+    BITBUCKET_BEARER_TOKEN=${BITBUCKET_BEARER_TOKEN} \
+    BITBUCKET_PR_ID=${BITBUCKET_PR_ID} \
+    BITBUCKET_REPO_SLUG=${BITBUCKET_REPO_SLUG} \
+    BITBUCKET_WORKSPACE=${BITBUCKET_WORKSPACE}
+
+
+WORKDIR /app
+ADD pyproject.toml .
+ADD requirements.txt .
+RUN pip install . && rm pyproject.toml requirements.txt
+ENV PYTHONPATH=/app
+ADD pr_agent pr_agent
+ADD bitbucket_pipeline/entrypoint.sh /
+RUN chmod +x /entrypoint.sh
+ENTRYPOINT ["/entrypoint.sh"]

INSTALL.md

@@ -375,7 +375,7 @@ In the "Trigger" section, check the ‘comments’ and ‘merge request events
 ### Method 9: Run as a Bitbucket Pipeline
 
 
-You can use the Bitbucket Pipeline system to run PR-Agent on every pull request open or update.
+You can use our pre-build Bitbucket-Pipeline docker image to run as Bitbucket-Pipeline.
 
 1. Add the following file in your repository bitbucket_pipelines.yml
 
@@ -384,19 +384,50 @@ pipelines:
     pull-requests:
       '**':
         - step:
-            name: PR Agent Review
-            image: python:3.10
+            name: PR Agent Pipeline
+            caches:
+              - pip
+            image: python:3.8
             services:
               - docker
             script:
-              - docker run -e CONFIG.GIT_PROVIDER=bitbucket -e OPENAI.KEY=$OPENAI_API_KEY -e BITBUCKET.BEARER_TOKEN=$BITBUCKET_BEARER_TOKEN codiumai/pr-agent:latest --pr_url=https://bitbucket.org/$BITBUCKET_WORKSPACE/$BITBUCKET_REPO_SLUG/pull-requests/$BITBUCKET_PR_ID review
+              - git clone https://github.com/Codium-ai/pr-agent.git
+              - cd pr-agent
+              - docker build -t bitbucket_runner:latest -f Dockerfile.bitbucket_pipeline .
+              - docker run -e OPENAI_API_KEY=$OPENAI_API_KEY -e BITBUCKET_BEARER_TOKEN=$BITBUCKET_BEARER_TOKEN -e BITBUCKET_PR_ID=$BITBUCKET_PR_ID -e BITBUCKET_REPO_SLUG=$BITBUCKET_REPO_SLUG -e BITBUCKET_WORKSPACE=$BITBUCKET_WORKSPACE bitbucket_runner:latest
 ```
 
-2. Add the following secure variables to your repository under Repository settings > Pipelines > Repository variables.
+2. Add the following secret to your repository under Repository settings > Pipelines > Repository variables.
 OPENAI_API_KEY: <your key>
 BITBUCKET_BEARER_TOKEN: <your token>
 
-You can get a Bitbucket token for your repository by following Repository Settings -> Security -> Access Tokens
+3. To get BITBUCKET_BEARER_TOKEN follow these steps
+  So here is my step by step tutorial
+  i) Insert your workspace name instead of {workspace_name} and go to the following link in order to create an OAuth consumer.
+
+      https://bitbucket.org/{workspace_name}/workspace/settings/api
+
+      set callback URL to http://localhost:8976 (doesn't need to be a real server there)
+      select permissions: repository -> read
+
+  ii) use consumer's Key as a {client_id} and open the following URL in the browser
+
+      https://bitbucket.org/site/oauth2/authorize?client_id={client_id}&response_type=code
+
+  iii)
+      after you press "Grant access" in the browser it will redirect you to
+
+      http://localhost:8976?code=<CODE>
+
+  iv) use the code from the previous step and consumer's Key as a {client_id}, and consumer's Secret as {client_secret}
+
+      curl -X POST -u "{client_id}:{client_secret}" \
+          https://bitbucket.org/site/oauth2/access_token \
+          -d grant_type=authorization_code \
+          -d code={code} \
+
+
+After completing this steps, you just to place this access token in the repository varibles.
 
 
 =======

bitbucket_pipeline/entrypoint.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+python /app/pr_agent/servers/bitbucket_pipeline_runner.py

docs/DESCRIBE.md

@@ -27,14 +27,18 @@ Under the section 'pr_description', the [configuration file](./../pr_agent/setti
 
 - `extra_instructions`: Optional extra instructions to the tool. For example: "focus on the changes in the file X. Ignore change in ...".
 
-### Markers template
+#### Markers template
 
 markers enable to easily integrate user's content and auto-generated content, with a template-like mechanism.
 
+- `use_description_markers`: if set to true, the tool will use markers template. It replaces every marker of the form `pr_agent:marker_name` with the relevant content. Default is false.
+
 For example, if the PR original description was:
 ```
 User content...
 
+## PR Type:
+pr_agent:pr_type
 
 ## PR Description:
 pr_agent:summary
@@ -42,21 +46,6 @@ pr_agent:summary
 ## PR Walkthrough:
 pr_agent:walkthrough
 ```
-The marker `pr_agent:summary` will be replaced with the PR summary, and `pr_agent:walkthrough` will be replaced with the PR walkthrough.
+The marker `pr_agent:pr_type` will be replaced with the PR type, `pr_agent:summary` will be replaced with the PR summary, and `pr_agent:walkthrough` will be replaced with the PR walkthrough.
 
-##### Example:
-```
-        env:
-          pr_description.use_description_markers: 'true'
-```          
-
-<kbd><img src=./../pics/describe_markers_before.png width="768"></kbd>
-
-==>
-
-<kbd><img src=./../pics/describe_markers_after.png width="768"></kbd>
-
-##### Configuration params:
-
-- `use_description_markers`: if set to true, the tool will use markers template. It replaces every marker of the form `pr_agent:marker_name` with the relevant content. Default is false.
 - `include_generated_by_header`: if set to true, the tool will add a dedicated header: 'Generated by PR Agent at ...' to any automatic content. Default is true.

docs/IMPROVE.md

@@ -32,14 +32,3 @@ Under the section 'pr_code_suggestions', the [configuration file](./../pr_agent/
 - `rank_extended_suggestions`: if set to true, the tool will rank the suggestions, based on importance. Default is true.
 - `max_number_of_calls`: maximum number of chunks. Default is 5.
 - `final_clip_factor`: factor to remove suggestions with low confidence. Default is 0.9.
-
-
-#### A note on code suggestions quality
-
-- With current level of AI for code (GPT-4), mistakes can happen. Not all the suggestions will be perfect, and a user should not accept all of them automatically.
-
-- Suggestions are not meant to be [simplistic](./../pr_agent/settings/pr_code_suggestions_prompts.toml#L34). Instead, they aim to give deep feedback and raise questions, ideas and thoughts to the user, who can then use his judgment, experience, and understanding of the code base.
-
-- Recommended to use the 'extra_instructions' field to guide the model to suggestions that are more relevant to the specific needs of the project.
-
-- Best quality will be obtained by using 'improve --extended' mode.

docs/REVIEW.md

@@ -44,14 +44,3 @@ The tool will first ask the author questions about the PR, and will guide the re
 <kbd><img src=./../pics/reflection_questions.png width="768"></kbd>
 <kbd><img src=./../pics/reflection_answers.png width="768"></kbd>
 <kbd><img src=./../pics/reflection_insights.png width="768"></kbd>
-
-
-#### A note on code suggestions quality
-
-- With current level of AI for code (GPT-4), mistakes can happen. Not all the suggestions will be perfect, and a user should not accept all of them automatically.
-
-- Suggestions are not meant to be [simplistic](./../pr_agent/settings/pr_reviewer_prompts.toml#L29). Instead, they aim to give deep feedback and raise questions, ideas and thoughts to the user, who can then use his judgment, experience, and understanding of the code base.
-
-- Recommended to use the 'extra_instructions' field to guide the model to suggestions that are more relevant to the specific needs of the project.
-
-- Unlike the 'review' feature, which does a lot of things, the ['improve --extended'](./IMPROVE.md) feature is dedicated only to suggestions, and usually gives better results.

pr_agent/agent/pr_agent.py

@@ -1,17 +1,20 @@
+import logging
+import os
 import shlex
+import tempfile
 
 from pr_agent.algo.utils import update_settings_from_args
 from pr_agent.config_loader import get_settings
-from pr_agent.git_providers.utils import apply_repo_settings
+from pr_agent.git_providers import get_git_provider
 from pr_agent.tools.pr_add_docs import PRAddDocs
 from pr_agent.tools.pr_code_suggestions import PRCodeSuggestions
-from pr_agent.tools.pr_config import PRConfig
 from pr_agent.tools.pr_description import PRDescription
 from pr_agent.tools.pr_information_from_user import PRInformationFromUser
+from pr_agent.tools.pr_similar_issue import PRSimilarIssue
 from pr_agent.tools.pr_questions import PRQuestions
 from pr_agent.tools.pr_reviewer import PRReviewer
-from pr_agent.tools.pr_similar_issue import PRSimilarIssue
 from pr_agent.tools.pr_update_changelog import PRUpdateChangelog
+from pr_agent.tools.pr_config import PRConfig
 
 command2class = {
     "auto_review": PRReviewer,
@@ -41,7 +44,22 @@ class PRAgent:
 
     async def handle_request(self, pr_url, request, notify=None) -> bool:
         # First, apply repo specific settings if exists
-        apply_repo_settings(pr_url)
+        if get_settings().config.use_repo_settings_file:
+            repo_settings_file = None
+            try:
+                git_provider = get_git_provider()(pr_url)
+                repo_settings = git_provider.get_repo_settings()
+                if repo_settings:
+                    repo_settings_file = None
+                    fd, repo_settings_file = tempfile.mkstemp(suffix='.toml')
+                    os.write(fd, repo_settings)
+                    get_settings().load_file(repo_settings_file)
+            finally:
+                if repo_settings_file:
+                    try:
+                        os.remove(repo_settings_file)
+                    except Exception as e:
+                        logging.error(f"Failed to remove temporary settings file {repo_settings_file}", e)
 
         # Then, apply user specific settings if exists
         request = request.replace("'", "\\'")
@@ -66,4 +84,3 @@ class PRAgent:
         else:
             return False
         return True
-

pr_agent/algo/ai_handler.py

@@ -1,3 +1,4 @@
+import logging
 import os
 
 import litellm
@@ -6,8 +7,6 @@ from litellm import acompletion
 from openai.error import APIError, RateLimitError, Timeout, TryAgain
 from retry import retry
 from pr_agent.config_loader import get_settings
-from pr_agent.log import get_logger
-
 OPENAI_RETRIES = 5
 
 
@@ -89,34 +88,34 @@ class AiHandler:
         try:
             deployment_id = self.deployment_id
             if get_settings().config.verbosity_level >= 2:
-                get_logger().debug(
+                logging.debug(
                     f"Generating completion with {model}"
                     f"{(' from deployment ' + deployment_id) if deployment_id else ''}"
                 )
             if self.azure:
                 model = 'azure/' + model
-            messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
             response = await acompletion(
                 model=model,
                 deployment_id=deployment_id,
-                messages=messages,
+                messages=[
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": user}
+                ],
                 temperature=temperature,
                 force_timeout=get_settings().config.ai_timeout
             )
         except (APIError, Timeout, TryAgain) as e:
-            get_logger().error("Error during OpenAI inference: ", e)
+            logging.error("Error during OpenAI inference: ", e)
             raise
         except (RateLimitError) as e:
-            get_logger().error("Rate limit error during OpenAI inference: ", e)
+            logging.error("Rate limit error during OpenAI inference: ", e)
             raise
         except (Exception) as e:
-            get_logger().error("Unknown error during OpenAI inference: ", e)
+            logging.error("Unknown error during OpenAI inference: ", e)
             raise TryAgain from e
         if response is None or len(response["choices"]) == 0:
             raise TryAgain
         resp = response["choices"][0]['message']['content']
         finish_reason = response["choices"][0]["finish_reason"]
-        usage = response.get("usage")
-        get_logger().info("AI response", response=resp, messages=messages, finish_reason=finish_reason,
-                          model=model, usage=usage)
+        print(resp, finish_reason)
         return resp, finish_reason

pr_agent/algo/git_patch_processing.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
-
+import logging
 import re
 
 from pr_agent.config_loader import get_settings
-from pr_agent.log import get_logger
 
 
 def extend_patch(original_file_str, patch_str, num_lines) -> str:
@@ -64,7 +63,7 @@ def extend_patch(original_file_str, patch_str, num_lines) -> str:
             extended_patch_lines.append(line)
     except Exception as e:
         if get_settings().config.verbosity_level >= 2:
-            get_logger().error(f"Failed to extend patch: {e}")
+            logging.error(f"Failed to extend patch: {e}")
         return patch_str
 
     # finish previous hunk
@@ -135,14 +134,14 @@ def handle_patch_deletions(patch: str, original_file_content_str: str,
     if not new_file_content_str:
         # logic for handling deleted files - don't show patch, just show that the file was deleted
         if get_settings().config.verbosity_level > 0:
-            get_logger().info(f"Processing file: {file_name}, minimizing deletion file")
+            logging.info(f"Processing file: {file_name}, minimizing deletion file")
         patch = None # file was deleted
     else:
         patch_lines = patch.splitlines()
         patch_new = omit_deletion_hunks(patch_lines)
         if patch != patch_new:
             if get_settings().config.verbosity_level > 0:
-                get_logger().info(f"Processing file: {file_name}, hunks were deleted")
+                logging.info(f"Processing file: {file_name}, hunks were deleted")
             patch = patch_new
     return patch
 

pr_agent/algo/pr_processing.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import difflib
+import logging
 import re
 import traceback
 from typing import Any, Callable, List, Tuple
@@ -14,7 +15,6 @@ from pr_agent.algo.file_filter import filter_ignored
 from pr_agent.algo.token_handler import TokenHandler, get_token_encoder
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers.git_provider import FilePatchInfo, GitProvider
-from pr_agent.log import get_logger
 
 DELETED_FILES_ = "Deleted files:\n"
 
@@ -51,7 +51,7 @@ def get_pr_diff(git_provider: GitProvider, token_handler: TokenHandler, model: s
     try:
         diff_files = git_provider.get_diff_files()
     except RateLimitExceededException as e:
-        get_logger().error(f"Rate limit exceeded for git provider API. original message {e}")
+        logging.error(f"Rate limit exceeded for git provider API. original message {e}")
         raise
 
     diff_files = filter_ignored(diff_files)
@@ -180,7 +180,7 @@ def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler, mo
 
         # Hard Stop, no more tokens
         if total_tokens > MAX_TOKENS[model] - OUTPUT_BUFFER_TOKENS_HARD_THRESHOLD:
-            get_logger().warning(f"File was fully skipped, no more tokens: {file.filename}.")
+            logging.warning(f"File was fully skipped, no more tokens: {file.filename}.")
             continue
 
         # If the patch is too large, just show the file name
@@ -189,7 +189,7 @@ def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler, mo
             # TODO: Option for alternative logic to remove hunks from the patch to reduce the number of tokens
             #  until we meet the requirements
             if get_settings().config.verbosity_level >= 2:
-                get_logger().warning(f"Patch too large, minimizing it, {file.filename}")
+                logging.warning(f"Patch too large, minimizing it, {file.filename}")
             if not modified_files_list:
                 total_tokens += token_handler.count_tokens(MORE_MODIFIED_FILES_)
             modified_files_list.append(file.filename)
@@ -204,7 +204,7 @@ def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler, mo
             patches.append(patch_final)
             total_tokens += token_handler.count_tokens(patch_final)
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Tokens: {total_tokens}, last filename: {file.filename}")
+                logging.info(f"Tokens: {total_tokens}, last filename: {file.filename}")
 
     return patches, modified_files_list, deleted_files_list
 
@@ -218,7 +218,7 @@ async def retry_with_fallback_models(f: Callable):
             get_settings().set("openai.deployment_id", deployment_id)
             return await f(model)
         except Exception as e:
-            get_logger().warning(
+            logging.warning(
                 f"Failed to generate prediction with {model}"
                 f"{(' from deployment ' + deployment_id) if deployment_id else ''}: "
                 f"{traceback.format_exc()}"
@@ -340,7 +340,7 @@ def clip_tokens(text: str, max_tokens: int) -> str:
         clipped_text = text[:num_output_chars]
         return clipped_text
     except Exception as e:
-        get_logger().warning(f"Failed to clip tokens: {e}")
+        logging.warning(f"Failed to clip tokens: {e}")
         return text
 
 
@@ -367,7 +367,7 @@ def get_pr_multi_diffs(git_provider: GitProvider,
     try:
         diff_files = git_provider.get_diff_files()
     except RateLimitExceededException as e:
-        get_logger().error(f"Rate limit exceeded for git provider API. original message {e}")
+        logging.error(f"Rate limit exceeded for git provider API. original message {e}")
         raise
 
     diff_files = filter_ignored(diff_files)
@@ -387,7 +387,7 @@ def get_pr_multi_diffs(git_provider: GitProvider,
     for file in sorted_files:
         if call_number > max_calls:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Reached max calls ({max_calls})")
+                logging.info(f"Reached max calls ({max_calls})")
             break
 
         original_file_content_str = file.base_file
@@ -410,13 +410,13 @@ def get_pr_multi_diffs(git_provider: GitProvider,
             total_tokens = token_handler.prompt_tokens
             call_number += 1
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Call number: {call_number}")
+                logging.info(f"Call number: {call_number}")
 
         if patch:
             patches.append(patch)
             total_tokens += new_patch_tokens
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Tokens: {total_tokens}, last filename: {file.filename}")
+                logging.info(f"Tokens: {total_tokens}, last filename: {file.filename}")
 
     # Add the last chunk
     if patches:

pr_agent/algo/utils.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import difflib
 import json
+import logging
 import re
 import textwrap
 from datetime import datetime
@@ -10,7 +11,6 @@ from typing import Any, List
 import yaml
 from starlette_context import context
 from pr_agent.config_loader import get_settings, global_settings
-from pr_agent.log import get_logger
 
 
 def get_setting(key: str) -> Any:
@@ -159,7 +159,7 @@ def try_fix_json(review, max_iter=10, code_suggestions=False):
                 iter_count += 1
 
         if not valid_json:
-            get_logger().error("Unable to decode JSON response from AI")
+            logging.error("Unable to decode JSON response from AI")
             data = {}
 
     return data
@@ -230,7 +230,7 @@ def load_large_diff(filename, new_file_content_str: str, original_file_content_s
         diff = difflib.unified_diff(original_file_content_str.splitlines(keepends=True),
                                     new_file_content_str.splitlines(keepends=True))
         if get_settings().config.verbosity_level >= 2:
-            get_logger().warning(f"File was modified, but no patch was found. Manually creating patch: {filename}.")
+            logging.warning(f"File was modified, but no patch was found. Manually creating patch: {filename}.")
         patch = ''.join(diff)
     except Exception:
         pass
@@ -262,12 +262,12 @@ def update_settings_from_args(args: List[str]) -> List[str]:
                 vals = arg.split('=', 1)
                 if len(vals) != 2:
                     if len(vals) > 2: # --extended is a valid argument
-                        get_logger().error(f'Invalid argument format: {arg}')
+                        logging.error(f'Invalid argument format: {arg}')
                     other_args.append(arg)
                     continue
                 key, value = _fix_key_value(*vals)
                 get_settings().set(key, value)
-                get_logger().info(f'Updated setting {key} to: "{value}"')
+                logging.info(f'Updated setting {key} to: "{value}"')
             else:
                 other_args.append(arg)
     return other_args
@@ -279,7 +279,7 @@ def _fix_key_value(key: str, value: str):
     try:
         value = yaml.safe_load(value)
     except Exception as e:
-        get_logger().error(f"Failed to parse YAML for config override {key}={value}", exc_info=e)
+        logging.error(f"Failed to parse YAML for config override {key}={value}", exc_info=e)
     return key, value
 
 
@@ -288,7 +288,7 @@ def load_yaml(review_text: str) -> dict:
     try:
         data = yaml.safe_load(review_text)
     except Exception as e:
-        get_logger().error(f"Failed to parse AI prediction: {e}")
+        logging.error(f"Failed to parse AI prediction: {e}")
         data = try_fix_yaml(review_text)
     return data
 
@@ -299,7 +299,7 @@ def try_fix_yaml(review_text: str) -> dict:
         review_text_lines_tmp = '\n'.join(review_text_lines[:-i])
         try:
             data = yaml.load(review_text_lines_tmp, Loader=yaml.SafeLoader)
-            get_logger().info(f"Successfully parsed AI prediction after removing {i} lines")
+            logging.info(f"Successfully parsed AI prediction after removing {i} lines")
             break
         except:
             pass

pr_agent/cli.py

@@ -1,12 +1,11 @@
 import argparse
 import asyncio
+import logging
 import os
 
 from pr_agent.agent.pr_agent import PRAgent, commands
 from pr_agent.config_loader import get_settings
-from pr_agent.log import setup_logger
 
-setup_logger()
 
 def run(inargs=None):
     parser = argparse.ArgumentParser(description='AI based pull request analyzer', usage=
@@ -48,6 +47,7 @@ For example: 'python cli.py --pr_url=... review --pr_reviewer.extra_instructions
         parser.print_help()
         return
 
+    logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
     command = args.command.lower()
     get_settings().set("CONFIG.CLI_MODE", True)
     if args.issue_url:

pr_agent/git_providers/azuredevops_provider.py

@@ -1,11 +1,10 @@
 import json
+import logging
 from typing import Optional, Tuple
 from urllib.parse import urlparse
 
 import os
 
-from ..log import get_logger
-
 AZURE_DEVOPS_AVAILABLE = True
 try:
     from msrest.authentication import BasicAuthentication
@@ -56,7 +55,7 @@ class AzureDevopsProvider:
                                                                  path=".pr_agent.toml")
             return contents
         except Exception as e:
-            get_logger().exception("get repo settings error")
+            logging.exception("get repo settings error")
             return ""
 
     def get_files(self):
@@ -111,7 +110,7 @@ class AzureDevopsProvider:
 
                     new_file_content_str = new_file_content_str.content
                 except Exception as error:
-                    get_logger().error("Failed to retrieve new file content of %s at version %s. Error: %s", file, version, str(error))
+                    logging.error("Failed to retrieve new file content of %s at version %s. Error: %s", file, version, str(error))
                     new_file_content_str = ""
 
                 edit_type = EDIT_TYPE.MODIFIED
@@ -132,7 +131,7 @@ class AzureDevopsProvider:
                                                                               include_content=True)
                     original_file_content_str = original_file_content_str.content
                 except Exception as error:
-                    get_logger().error("Failed to retrieve original file content of %s at version %s. Error: %s", file, version, str(error))
+                    logging.error("Failed to retrieve original file content of %s at version %s. Error: %s", file, version, str(error))
                     original_file_content_str = ""
 
                 patch = load_large_diff(file, new_file_content_str, original_file_content_str)
@@ -167,7 +166,7 @@ class AzureDevopsProvider:
                                                          pull_request_id=self.pr_num,
                                                          git_pull_request_to_update=updated_pr)
         except Exception as e:
-            get_logger().exception(f"Could not update pull request {self.pr_num} description: {e}")
+            logging.exception(f"Could not update pull request {self.pr_num} description: {e}")
 
     def remove_initial_comment(self):
         return ""  # not implemented yet
@@ -236,6 +235,9 @@ class AzureDevopsProvider:
     def _parse_pr_url(pr_url: str) -> Tuple[str, int]:
         parsed_url = urlparse(pr_url)
 
+        if 'azure.com' not in parsed_url.netloc:
+            raise ValueError("The provided URL is not a valid Azure DevOps URL")
+
         path_parts = parsed_url.path.strip('/').split('/')
 
         if len(path_parts) < 6 or path_parts[4] != 'pullrequest':

pr_agent/git_providers/bitbucket_provider.py

@@ -1,4 +1,5 @@
 import json
+import logging
 from typing import Optional, Tuple
 from urllib.parse import urlparse
 
@@ -6,9 +7,8 @@ import requests
 from atlassian.bitbucket import Cloud
 from starlette_context import context
 
-from ..algo.pr_processing import find_line_number_of_relevant_line_in_file
+from ..algo.pr_processing import clip_tokens, find_line_number_of_relevant_line_in_file
 from ..config_loader import get_settings
-from ..log import get_logger
 from .git_provider import FilePatchInfo, GitProvider
 
 
@@ -61,14 +61,14 @@ class BitbucketProvider(GitProvider):
 
             if not relevant_lines_start or relevant_lines_start == -1:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().exception(
+                    logging.exception(
                         f"Failed to publish code suggestion, relevant_lines_start is {relevant_lines_start}"
                     )
                 continue
 
             if relevant_lines_end < relevant_lines_start:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().exception(
+                    logging.exception(
                         f"Failed to publish code suggestion, "
                         f"relevant_lines_end is {relevant_lines_end} and "
                         f"relevant_lines_start is {relevant_lines_start}"
@@ -97,7 +97,7 @@ class BitbucketProvider(GitProvider):
             return True
         except Exception as e:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().error(f"Failed to publish code suggestion, error: {e}")
+                logging.error(f"Failed to publish code suggestion, error: {e}")
             return False
 
     def is_supported(self, capability: str) -> bool:
@@ -142,22 +142,17 @@ class BitbucketProvider(GitProvider):
     def remove_initial_comment(self):
         try:
             for comment in self.temp_comments:
-                self.remove_comment(comment)
-        except Exception as e:
-            get_logger().exception(f"Failed to remove temp comments, error: {e}")
-
-    def remove_comment(self, comment):
-        try:
                 self.pr.delete(f"comments/{comment}")
         except Exception as e:
-            get_logger().exception(f"Failed to remove comment, error: {e}")
+            logging.exception(f"Failed to remove temp comments, error: {e}")
+
 
     # funtion to create_inline_comment
     def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
         position, absolute_position = find_line_number_of_relevant_line_in_file(self.get_diff_files(), relevant_file.strip('`'), relevant_line_in_file)
         if position == -1:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
+                logging.info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
             subject_type = "FILE"
         else:
             subject_type = "LINE"

pr_agent/git_providers/codecommit_provider.py

@@ -1,15 +1,16 @@
+import logging
 import os
 import re
 from collections import Counter
 from typing import List, Optional, Tuple
 from urllib.parse import urlparse
 
-from pr_agent.git_providers.codecommit_client import CodeCommitClient
-
 from ..algo.language_handler import is_valid_file, language_extension_map
+from ..algo.pr_processing import clip_tokens
 from ..algo.utils import load_large_diff
-from .git_provider import EDIT_TYPE, FilePatchInfo, GitProvider
-from ..log import get_logger
+from ..config_loader import get_settings
+from .git_provider import EDIT_TYPE, FilePatchInfo, GitProvider, IncrementalPR
+from pr_agent.git_providers.codecommit_client import CodeCommitClient
 
 
 class PullRequestCCMimic:
@@ -165,7 +166,7 @@ class CodeCommitProvider(GitProvider):
 
     def publish_comment(self, pr_comment: str, is_temporary: bool = False):
         if is_temporary:
-            get_logger().info(pr_comment)
+            logging.info(pr_comment)
             return
 
         pr_comment = CodeCommitProvider._remove_markdown_html(pr_comment)
@@ -187,12 +188,12 @@ class CodeCommitProvider(GitProvider):
         for suggestion in code_suggestions:
             # Verify that each suggestion has the required keys
             if not all(key in suggestion for key in ["body", "relevant_file", "relevant_lines_start"]):
-                get_logger().warning(f"Skipping code suggestion #{counter}: Each suggestion must have 'body', 'relevant_file', 'relevant_lines_start' keys")
+                logging.warning(f"Skipping code suggestion #{counter}: Each suggestion must have 'body', 'relevant_file', 'relevant_lines_start' keys")
                 continue
        
             # Publish the code suggestion to CodeCommit
             try:
-                get_logger().debug(f"Code Suggestion #{counter} in file: {suggestion['relevant_file']}: {suggestion['relevant_lines_start']}")
+                logging.debug(f"Code Suggestion #{counter} in file: {suggestion['relevant_file']}: {suggestion['relevant_lines_start']}")
                 self.codecommit_client.publish_comment(
                     repo_name=self.repo_name,
                     pr_number=self.pr_num,
@@ -221,9 +222,6 @@ class CodeCommitProvider(GitProvider):
     def remove_initial_comment(self):
         return ""  # not implemented yet
 
-    def remove_comment(self, comment):
-        return ""  # not implemented yet
-
     def publish_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
         # https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/codecommit/client/post_comment_for_compared_commit.html
         raise NotImplementedError("CodeCommit provider does not support publishing inline comments yet")
@@ -298,11 +296,11 @@ class CodeCommitProvider(GitProvider):
         return self.codecommit_client.get_file(self.repo_name, settings_filename, self.pr.source_commit, optional=True)
 
     def add_eyes_reaction(self, issue_comment_id: int) -> Optional[int]:
-        get_logger().info("CodeCommit provider does not support eyes reaction yet")
+        logging.info("CodeCommit provider does not support eyes reaction yet")
         return True
 
     def remove_reaction(self, issue_comment_id: int, reaction_id: int) -> bool:
-        get_logger().info("CodeCommit provider does not support removing reactions yet")
+        logging.info("CodeCommit provider does not support removing reactions yet")
         return True
 
     @staticmethod
@@ -368,7 +366,7 @@ class CodeCommitProvider(GitProvider):
         # TODO: implement support for multiple targets in one CodeCommit PR
         #       for now, we are only using the first target in the PR
         if len(response.targets) > 1:
-            get_logger().warning(
+            logging.warning(
                 "Multiple targets in one PR is not supported for CodeCommit yet. Continuing, using the first target only..."
             )
 

pr_agent/git_providers/gerrit_provider.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 import pathlib
 import shutil
@@ -6,16 +7,18 @@ import subprocess
 import uuid
 from collections import Counter, namedtuple
 from pathlib import Path
-from tempfile import NamedTemporaryFile, mkdtemp
+from tempfile import mkdtemp, NamedTemporaryFile
 
 import requests
 import urllib3.util
 from git import Repo
 
 from pr_agent.config_loader import get_settings
-from pr_agent.git_providers.git_provider import EDIT_TYPE, FilePatchInfo, GitProvider
+from pr_agent.git_providers.git_provider import GitProvider, FilePatchInfo, \
+    EDIT_TYPE
 from pr_agent.git_providers.local_git_provider import PullRequestMimic
-from pr_agent.log import get_logger
+
+logger = logging.getLogger(__name__)
 
 
 def _call(*command, **kwargs) -> (int, str, str):
@@ -30,42 +33,42 @@ def _call(*command, **kwargs) -> (int, str, str):
 
 
 def clone(url, directory):
-    get_logger().info("Cloning %s to %s", url, directory)
+    logger.info("Cloning %s to %s", url, directory)
     stdout = _call('git', 'clone', "--depth", "1", url, directory)
-    get_logger().info(stdout)
+    logger.info(stdout)
 
 
 def fetch(url, refspec, cwd):
-    get_logger().info("Fetching %s %s", url, refspec)
+    logger.info("Fetching %s %s", url, refspec)
     stdout = _call(
         'git', 'fetch', '--depth', '2', url, refspec,
         cwd=cwd
     )
-    get_logger().info(stdout)
+    logger.info(stdout)
 
 
 def checkout(cwd):
-    get_logger().info("Checking out")
+    logger.info("Checking out")
     stdout = _call('git', 'checkout', "FETCH_HEAD", cwd=cwd)
-    get_logger().info(stdout)
+    logger.info(stdout)
 
 
 def show(*args, cwd=None):
-    get_logger().info("Show")
+    logger.info("Show")
     return _call('git', 'show', *args, cwd=cwd)
 
 
 def diff(*args, cwd=None):
-    get_logger().info("Diff")
+    logger.info("Diff")
     patch = _call('git', 'diff', *args, cwd=cwd)
     if not patch:
-        get_logger().warning("No changes found")
+        logger.warning("No changes found")
         return
     return patch
 
 
 def reset_local_changes(cwd):
-    get_logger().info("Reset local changes")
+    logger.info("Reset local changes")
     _call('git', 'checkout', "--force", cwd=cwd)
 
 
@@ -396,8 +399,5 @@ class GerritProvider(GitProvider):
         # shutil.rmtree(self.repo_path)
         pass
 
-    def remove_comment(self, comment):
-        pass
-
     def get_pr_branch(self):
         return self.repo.head

pr_agent/git_providers/git_provider.py

@@ -1,3 +1,4 @@
+import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
@@ -5,8 +6,6 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
 
-from pr_agent.log import get_logger
-
 
 class EDIT_TYPE(Enum):
     ADDED = 1
@@ -71,10 +70,6 @@ class GitProvider(ABC):
     def remove_initial_comment(self):
         pass
 
-    @abstractmethod
-    def remove_comment(self, comment):
-        pass
-
     @abstractmethod
     def get_languages(self):
         pass
@@ -141,7 +136,7 @@ def get_main_pr_language(languages, files) -> str:
     """
     main_language_str = ""
     if not languages:
-        get_logger().info("No languages detected")
+        logging.info("No languages detected")
         return main_language_str
 
     try:
@@ -177,7 +172,7 @@ def get_main_pr_language(languages, files) -> str:
             main_language_str = top_language
 
     except Exception as e:
-        get_logger().exception(e)
+        logging.exception(e)
         pass
 
     return main_language_str

pr_agent/git_providers/github_provider.py

@@ -1,19 +1,20 @@
+import logging
 import hashlib
+
 from datetime import datetime
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Any
 from urllib.parse import urlparse
 
-from github import AppAuthentication, Auth, Github, GithubException
+from github import AppAuthentication, Auth, Github, GithubException, Reaction
 from retry import retry
 from starlette_context import context
 
-from ..algo.language_handler import is_valid_file
-from ..algo.pr_processing import clip_tokens, find_line_number_of_relevant_line_in_file
-from ..algo.utils import load_large_diff
-from ..config_loader import get_settings
-from ..log import get_logger
-from ..servers.utils import RateLimitExceeded
 from .git_provider import FilePatchInfo, GitProvider, IncrementalPR
+from ..algo.language_handler import is_valid_file
+from ..algo.utils import load_large_diff
+from ..algo.pr_processing import find_line_number_of_relevant_line_in_file, clip_tokens
+from ..config_loader import get_settings
+from ..servers.utils import RateLimitExceeded
 
 
 class GithubProvider(GitProvider):
@@ -50,20 +51,20 @@ class GithubProvider(GitProvider):
     def get_incremental_commits(self):
         self.commits = list(self.pr.get_commits())
 
-        self.previous_review = self.get_previous_review(full=True, incremental=True)
+        self.get_previous_review()
         if self.previous_review:
             self.incremental.commits_range = self.get_commit_range()
             # Get all files changed during the commit range
             self.file_set = dict()
             for commit in self.incremental.commits_range:
                 if commit.commit.message.startswith(f"Merge branch '{self._get_repo().default_branch}'"):
-                    get_logger().info(f"Skipping merge commit {commit.commit.message}")
+                    logging.info(f"Skipping merge commit {commit.commit.message}")
                     continue
                 self.file_set.update({file.filename: file for file in commit.files})
 
     def get_commit_range(self):
         last_review_time = self.previous_review.created_at
-        first_new_commit_index = None
+        first_new_commit_index = 0
         for index in range(len(self.commits) - 1, -1, -1):
             if self.commits[index].commit.author.date > last_review_time:
                 self.incremental.first_new_commit_sha = self.commits[index].sha
@@ -71,21 +72,15 @@ class GithubProvider(GitProvider):
             else:
                 self.incremental.last_seen_commit_sha = self.commits[index].sha
                 break
-        return self.commits[first_new_commit_index:] if first_new_commit_index is not None else []
+        return self.commits[first_new_commit_index:]
 
-    def get_previous_review(self, *, full: bool, incremental: bool):
-        if not (full or incremental):
-            raise ValueError("At least one of full or incremental must be True")
-        if not getattr(self, "comments", None):
+    def get_previous_review(self):
+        self.previous_review = None
         self.comments = list(self.pr.get_issue_comments())
-        prefixes = []
-        if full:
-            prefixes.append("## PR Analysis")
-        if incremental:
-            prefixes.append("## Incremental PR Review")
         for index in range(len(self.comments) - 1, -1, -1):
-            if any(self.comments[index].body.startswith(prefix) for prefix in prefixes):
-                return self.comments[index]
+            if self.comments[index].body.startswith("## PR Analysis"):
+                self.previous_review = self.comments[index]
+                break
 
     def get_files(self):
         if self.incremental.is_incremental and self.file_set:
@@ -135,7 +130,7 @@ class GithubProvider(GitProvider):
             return diff_files
 
         except GithubException.RateLimitExceededException as e:
-            get_logger().error(f"Rate limit exceeded for GitHub API. Original message: {e}")
+            logging.error(f"Rate limit exceeded for GitHub API. Original message: {e}")
             raise RateLimitExceeded("Rate limit exceeded for GitHub API.") from e
 
     def publish_description(self, pr_title: str, pr_body: str):
@@ -143,7 +138,7 @@ class GithubProvider(GitProvider):
 
     def publish_comment(self, pr_comment: str, is_temporary: bool = False):
         if is_temporary and not get_settings().config.publish_output_progress:
-            get_logger().debug(f"Skipping publish_comment for temporary comment: {pr_comment}")
+            logging.debug(f"Skipping publish_comment for temporary comment: {pr_comment}")
             return
         response = self.pr.create_issue_comment(pr_comment)
         if hasattr(response, "user") and hasattr(response.user, "login"):
@@ -161,7 +156,7 @@ class GithubProvider(GitProvider):
         position, absolute_position = find_line_number_of_relevant_line_in_file(self.diff_files, relevant_file.strip('`'), relevant_line_in_file)
         if position == -1:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
+                logging.info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
             subject_type = "FILE"
         else:
             subject_type = "LINE"
@@ -184,13 +179,13 @@ class GithubProvider(GitProvider):
 
             if not relevant_lines_start or relevant_lines_start == -1:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().exception(
+                    logging.exception(
                         f"Failed to publish code suggestion, relevant_lines_start is {relevant_lines_start}")
                 continue
 
             if relevant_lines_end < relevant_lines_start:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().exception(f"Failed to publish code suggestion, "
+                    logging.exception(f"Failed to publish code suggestion, "
                                       f"relevant_lines_end is {relevant_lines_end} and "
                                       f"relevant_lines_start is {relevant_lines_start}")
                 continue
@@ -217,22 +212,16 @@ class GithubProvider(GitProvider):
             return True
         except Exception as e:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().error(f"Failed to publish code suggestion, error: {e}")
+                logging.error(f"Failed to publish code suggestion, error: {e}")
             return False
 
     def remove_initial_comment(self):
         try:
             for comment in getattr(self.pr, 'comments_list', []):
                 if comment.is_temporary:
-                    self.remove_comment(comment)
-        except Exception as e:
-            get_logger().exception(f"Failed to remove initial comment, error: {e}")
-
-    def remove_comment(self, comment):
-        try:
                     comment.delete()
         except Exception as e:
-            get_logger().exception(f"Failed to remove comment, error: {e}")
+            logging.exception(f"Failed to remove initial comment, error: {e}")
 
     def get_title(self):
         return self.pr.title
@@ -280,7 +269,7 @@ class GithubProvider(GitProvider):
             reaction = self.pr.get_issue_comment(issue_comment_id).create_reaction("eyes")
             return reaction.id
         except Exception as e:
-            get_logger().exception(f"Failed to add eyes reaction, error: {e}")
+            logging.exception(f"Failed to add eyes reaction, error: {e}")
             return None
 
     def remove_reaction(self, issue_comment_id: int, reaction_id: int) -> bool:
@@ -288,7 +277,7 @@ class GithubProvider(GitProvider):
             self.pr.get_issue_comment(issue_comment_id).delete_reaction(reaction_id)
             return True
         except Exception as e:
-            get_logger().exception(f"Failed to remove eyes reaction, error: {e}")
+            logging.exception(f"Failed to remove eyes reaction, error: {e}")
             return False
 
 
@@ -407,13 +396,13 @@ class GithubProvider(GitProvider):
                 "PUT", f"{self.pr.issue_url}/labels", input=post_parameters
             )
         except Exception as e:
-            get_logger().exception(f"Failed to publish labels, error: {e}")
+            logging.exception(f"Failed to publish labels, error: {e}")
 
     def get_labels(self):
         try:
             return [label.name for label in self.pr.labels]
         except Exception as e:
-            get_logger().exception(f"Failed to get labels, error: {e}")
+            logging.exception(f"Failed to get labels, error: {e}")
             return []
 
     def get_commit_messages(self):
@@ -455,7 +444,7 @@ class GithubProvider(GitProvider):
                 return link
         except Exception as e:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Failed adding line link, error: {e}")
+                logging.info(f"Failed adding line link, error: {e}")
 
         return ""
 

pr_agent/git_providers/gitlab_provider.py

@@ -1,4 +1,5 @@
 import hashlib
+import logging
 import re
 from typing import Optional, Tuple
 from urllib.parse import urlparse
@@ -11,8 +12,8 @@ from ..algo.pr_processing import clip_tokens, find_line_number_of_relevant_line_
 from ..algo.utils import load_large_diff
 from ..config_loader import get_settings
 from .git_provider import EDIT_TYPE, FilePatchInfo, GitProvider
-from ..log import get_logger
 
+logger = logging.getLogger()
 
 class DiffNotFoundError(Exception):
     """Raised when the diff for a merge request cannot be found."""
@@ -58,7 +59,7 @@ class GitLabProvider(GitProvider):
         try:
             self.last_diff = self.mr.diffs.list(get_all=True)[-1]
         except IndexError as e:
-            get_logger().error(f"Could not get diff for merge request {self.id_mr}")
+            logger.error(f"Could not get diff for merge request {self.id_mr}")
             raise DiffNotFoundError(f"Could not get diff for merge request {self.id_mr}") from e
 
 
@@ -98,7 +99,7 @@ class GitLabProvider(GitProvider):
                     if isinstance(new_file_content_str, bytes):
                         new_file_content_str = bytes.decode(new_file_content_str, 'utf-8')
                 except UnicodeDecodeError:
-                    get_logger().warning(
+                    logging.warning(
                         f"Cannot decode file {diff['old_path']} or {diff['new_path']} in merge request {self.id_mr}")
 
                 edit_type = EDIT_TYPE.MODIFIED
@@ -134,7 +135,7 @@ class GitLabProvider(GitProvider):
             self.mr.description = pr_body
             self.mr.save()
         except Exception as e:
-            get_logger().exception(f"Could not update merge request {self.id_mr} description: {e}")
+            logging.exception(f"Could not update merge request {self.id_mr} description: {e}")
 
     def publish_comment(self, mr_comment: str, is_temporary: bool = False):
         comment = self.mr.notes.create({'body': mr_comment})
@@ -156,12 +157,12 @@ class GitLabProvider(GitProvider):
     def send_inline_comment(self,body: str,edit_type: str,found: bool,relevant_file: str,relevant_line_in_file: int,
                             source_line_no: int, target_file: str,target_line_no: int) -> None:
         if not found:
-            get_logger().info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
+            logging.info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
         else:
             # in order to have exact sha's we have to find correct diff for this change
             diff = self.get_relevant_diff(relevant_file, relevant_line_in_file)
             if diff is None:
-                get_logger().error(f"Could not get diff for merge request {self.id_mr}")
+                logger.error(f"Could not get diff for merge request {self.id_mr}")
                 raise DiffNotFoundError(f"Could not get diff for merge request {self.id_mr}")
             pos_obj = {'position_type': 'text',
                        'new_path': target_file.filename,
@@ -174,23 +175,23 @@ class GitLabProvider(GitProvider):
             else:
                 pos_obj['new_line'] = target_line_no - 1
                 pos_obj['old_line'] = source_line_no - 1
-            get_logger().debug(f"Creating comment in {self.id_mr} with body {body} and position {pos_obj}")
+            logging.debug(f"Creating comment in {self.id_mr} with body {body} and position {pos_obj}")
             self.mr.discussions.create({'body': body, 'position': pos_obj})
 
     def get_relevant_diff(self, relevant_file: str, relevant_line_in_file: int) -> Optional[dict]:
         changes = self.mr.changes()  # Retrieve the changes for the merge request once
         if not changes:
-            get_logger().error('No changes found for the merge request.')
+            logging.error('No changes found for the merge request.')
             return None
         all_diffs = self.mr.diffs.list(get_all=True)
         if not all_diffs:
-            get_logger().error('No diffs found for the merge request.')
+            logging.error('No diffs found for the merge request.')
             return None
         for diff in all_diffs:
             for change in changes['changes']:
                 if change['new_path'] == relevant_file and relevant_line_in_file in change['diff']:
                     return diff
-            get_logger().debug(
+            logging.debug(
                 f'No relevant diff found for {relevant_file} {relevant_line_in_file}. Falling back to last diff.')
         return self.last_diff  # fallback to last_diff if no relevant diff is found
 
@@ -225,7 +226,7 @@ class GitLabProvider(GitProvider):
                 self.send_inline_comment(body, edit_type, found, relevant_file, relevant_line_in_file, source_line_no,
                                          target_file, target_line_no)
             except Exception as e:
-                get_logger().exception(f"Could not publish code suggestion:\nsuggestion: {suggestion}\nerror: {e}")
+                logging.exception(f"Could not publish code suggestion:\nsuggestion: {suggestion}\nerror: {e}")
 
         # note that we publish suggestions one-by-one. so, if one fails, the rest will still be published
         return True
@@ -287,15 +288,9 @@ class GitLabProvider(GitProvider):
     def remove_initial_comment(self):
         try:
             for comment in self.temp_comments:
-                self.remove_comment(comment)
-        except Exception as e:
-            get_logger().exception(f"Failed to remove temp comments, error: {e}")
-
-    def remove_comment(self, comment):
-        try:
                 comment.delete()
         except Exception as e:
-            get_logger().exception(f"Failed to remove comment, error: {e}")
+            logging.exception(f"Failed to remove temp comments, error: {e}")
 
     def get_title(self):
         return self.mr.title
@@ -363,7 +358,7 @@ class GitLabProvider(GitProvider):
             self.mr.labels = list(set(pr_types))
             self.mr.save()
         except Exception as e:
-            get_logger().exception(f"Failed to publish labels, error: {e}")
+            logging.exception(f"Failed to publish labels, error: {e}")
 
     def publish_inline_comments(self, comments: list[dict]):
         pass
@@ -415,6 +410,6 @@ class GitLabProvider(GitProvider):
                 return link
         except Exception as e:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Failed adding line link, error: {e}")
+                logging.info(f"Failed adding line link, error: {e}")
 
         return ""

pr_agent/git_providers/local_git_provider.py

@@ -1,3 +1,4 @@
+import logging
 from collections import Counter
 from pathlib import Path
 from typing import List
@@ -6,7 +7,6 @@ from git import Repo
 
 from pr_agent.config_loader import _find_repository_root, get_settings
 from pr_agent.git_providers.git_provider import EDIT_TYPE, FilePatchInfo, GitProvider
-from pr_agent.log import get_logger
 
 
 class PullRequestMimic:
@@ -49,7 +49,7 @@ class LocalGitProvider(GitProvider):
         """
         Prepare the repository for PR-mimic generation.
         """
-        get_logger().debug('Preparing repository for PR-mimic generation...')
+        logging.debug('Preparing repository for PR-mimic generation...')
         if self.repo.is_dirty():
             raise ValueError('The repository is not in a clean state. Please commit or stash pending changes.')
         if self.target_branch_name not in self.repo.heads:
@@ -140,9 +140,6 @@ class LocalGitProvider(GitProvider):
     def remove_initial_comment(self):
         pass  # Not applicable to the local git provider, but required by the interface
 
-    def remove_comment(self, comment):
-        pass  # Not applicable to the local git provider, but required by the interface
-
     def get_languages(self):
         """
         Calculate percentage of languages in repository. Used for hunk prioritisation.

pr_agent/git_providers/utils.py

@@ -1,35 +0,0 @@
-import copy
-import os
-import tempfile
-
-from dynaconf import Dynaconf
-
-from pr_agent.config_loader import get_settings
-from pr_agent.git_providers import get_git_provider
-from pr_agent.log import get_logger
-
-
-def apply_repo_settings(pr_url):
-    if get_settings().config.use_repo_settings_file:
-        repo_settings_file = None
-        try:
-            git_provider = get_git_provider()(pr_url)
-            repo_settings = git_provider.get_repo_settings()
-            if repo_settings:
-                repo_settings_file = None
-                fd, repo_settings_file = tempfile.mkstemp(suffix='.toml')
-                os.write(fd, repo_settings)
-                new_settings = Dynaconf(settings_files=[repo_settings_file])
-                for section, contents in new_settings.as_dict().items():
-                    section_dict = copy.deepcopy(get_settings().as_dict().get(section, {}))
-                    for key, value in contents.items():
-                        section_dict[key] = value
-                    get_settings().unset(section)
-                    get_settings().set(section, section_dict, merge=False)
-
-        finally:
-            if repo_settings_file:
-                try:
-                    os.remove(repo_settings_file)
-                except Exception as e:
-                    get_logger().error(f"Failed to remove temporary settings file {repo_settings_file}", e)

pr_agent/log/__init__.py

@@ -1,40 +0,0 @@
-import json
-import logging
-import sys
-from enum import Enum
-
-from loguru import logger
-
-
-class LoggingFormat(str, Enum):
-    CONSOLE = "CONSOLE"
-    JSON = "JSON"
-
-
-def json_format(record: dict) -> str:
-    return record["message"]
-
-
-def setup_logger(level: str = "INFO", fmt: LoggingFormat = LoggingFormat.CONSOLE):
-    level: int = logging.getLevelName(level.upper())
-    if type(level) is not int:
-        level = logging.INFO
-
-    if fmt == LoggingFormat.JSON:
-        logger.remove(None)
-        logger.add(
-            sys.stdout,
-            level=level,
-            format="{message}",
-            colorize=False,
-            serialize=True,
-        )
-    elif fmt == LoggingFormat.CONSOLE:
-        logger.remove(None)
-        logger.add(sys.stdout, level=level, colorize=True)
-
-    return logger
-
-
-def get_logger(*args, **kwargs):
-    return logger

pr_agent/secret_providers/google_cloud_storage_secret_provider.py

@@ -1,8 +1,9 @@
 import ujson
+
 from google.cloud import storage
 
 from pr_agent.config_loader import get_settings
-from pr_agent.log import get_logger
+from pr_agent.git_providers.gitlab_provider import logger
 from pr_agent.secret_providers.secret_provider import SecretProvider
 
 
@@ -14,7 +15,7 @@ class GoogleCloudStorageSecretProvider(SecretProvider):
             self.bucket_name = get_settings().google_cloud_storage.bucket_name
             self.bucket = self.client.bucket(self.bucket_name)
         except Exception as e:
-            get_logger().error(f"Failed to initialize Google Cloud Storage Secret Provider: {e}")
+            logger.error(f"Failed to initialize Google Cloud Storage Secret Provider: {e}")
             raise e
 
     def get_secret(self, secret_name: str) -> str:
@@ -22,7 +23,7 @@ class GoogleCloudStorageSecretProvider(SecretProvider):
             blob = self.bucket.blob(secret_name)
             return blob.download_as_string()
         except Exception as e:
-            get_logger().error(f"Failed to get secret {secret_name} from Google Cloud Storage: {e}")
+            logger.error(f"Failed to get secret {secret_name} from Google Cloud Storage: {e}")
             return ""
 
     def store_secret(self, secret_name: str, secret_value: str):
@@ -30,5 +31,5 @@ class GoogleCloudStorageSecretProvider(SecretProvider):
             blob = self.bucket.blob(secret_name)
             blob.upload_from_string(secret_value)
         except Exception as e:
-            get_logger().error(f"Failed to store secret {secret_name} in Google Cloud Storage: {e}")
+            logger.error(f"Failed to store secret {secret_name} in Google Cloud Storage: {e}")
             raise e

pr_agent/servers/bitbucket_app.py

@@ -1,7 +1,9 @@
 import copy
 import hashlib
 import json
+import logging
 import os
+import sys
 import time
 
 import jwt
@@ -16,10 +18,9 @@ from starlette_context.middleware import RawContextMiddleware
 
 from pr_agent.agent.pr_agent import PRAgent
 from pr_agent.config_loader import get_settings, global_settings
-from pr_agent.log import LoggingFormat, get_logger, setup_logger
 from pr_agent.secret_providers import get_secret_provider
 
-setup_logger(fmt=LoggingFormat.JSON)
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
 router = APIRouter()
 secret_provider = get_secret_provider()
 
@@ -48,7 +49,7 @@ async def get_bearer_token(shared_secret: str, client_key: str):
         bearer_token = response.json()["access_token"]
         return bearer_token
     except Exception as e:
-        get_logger().error(f"Failed to get bearer token: {e}")
+        logging.error(f"Failed to get bearer token: {e}")
         raise e
 
 @router.get("/")
@@ -59,23 +60,21 @@ async def handle_manifest(request: Request, response: Response):
         manifest = manifest.replace("app_key", get_settings().bitbucket.app_key)
         manifest = manifest.replace("base_url", get_settings().bitbucket.base_url)
     except:
-        get_logger().error("Failed to replace api_key in Bitbucket manifest, trying to continue")
+        logging.error("Failed to replace api_key in Bitbucket manifest, trying to continue")
     manifest_obj = json.loads(manifest)
     return JSONResponse(manifest_obj)
 
 @router.post("/webhook")
 async def handle_github_webhooks(background_tasks: BackgroundTasks, request: Request):
-    log_context = {"server_type": "bitbucket_app"}
-    get_logger().debug(request.headers)
+    print(request.headers)
     jwt_header = request.headers.get("authorization", None)
     if jwt_header:
         input_jwt = jwt_header.split(" ")[1]
     data = await request.json()
-    get_logger().debug(data)
+    print(data)
     async def inner():
         try:
             owner = data["data"]["repository"]["owner"]["username"]
-            log_context["sender"] = owner
             secrets = json.loads(secret_provider.get_secret(owner))
             shared_secret = secrets["shared_secret"]
             client_key = secrets["client_key"]
@@ -87,19 +86,13 @@ async def handle_github_webhooks(background_tasks: BackgroundTasks, request: Req
             agent = PRAgent()
             if event == "pullrequest:created":
                 pr_url = data["data"]["pullrequest"]["links"]["html"]["href"]
-                log_context["api_url"] = pr_url
-                log_context["event"] = "pull_request"
-                with get_logger().contextualize(**log_context):
                 await agent.handle_request(pr_url, "review")
             elif event == "pullrequest:comment_created":
                 pr_url = data["data"]["pullrequest"]["links"]["html"]["href"]
-                log_context["api_url"] = pr_url
-                log_context["event"] = "comment"
                 comment_body = data["data"]["comment"]["content"]["raw"]
-                with get_logger().contextualize(**log_context):
                 await agent.handle_request(pr_url, comment_body)
         except Exception as e:
-            get_logger().error(f"Failed to handle webhook: {e}")
+            logging.error(f"Failed to handle webhook: {e}")
     background_tasks.add_task(inner)
     return "OK"
 
@@ -110,10 +103,9 @@ async def handle_github_webhooks(request: Request, response: Response):
 @router.post("/installed")
 async def handle_installed_webhooks(request: Request, response: Response):
     try:
-        get_logger().info("handle_installed_webhooks")
-        get_logger().info(request.headers)
+        print(request.headers)
         data = await request.json()
-        get_logger().info(data)
+        print(data)
         shared_secret = data["sharedSecret"]
         client_key = data["clientKey"]
         username = data["principal"]["username"]
@@ -123,15 +115,13 @@ async def handle_installed_webhooks(request: Request, response: Response):
         }
         secret_provider.store_secret(username, json.dumps(secrets))
     except Exception as e:
-        get_logger().error(f"Failed to register user: {e}")
+        logging.error(f"Failed to register user: {e}")
         return JSONResponse({"error": "Unable to register user"}, status_code=500)
 
 @router.post("/uninstalled")
 async def handle_uninstalled_webhooks(request: Request, response: Response):
-    get_logger().info("handle_uninstalled_webhooks")
-
     data = await request.json()
-    get_logger().info(data)
+    print(data)
 
 
 def start():

pr_agent/servers/bitbucket_pipeline_runner.py

@@ -0,0 +1,34 @@
+import os
+from pr_agent.agent.pr_agent import PRAgent
+from pr_agent.config_loader import get_settings
+from pr_agent.tools.pr_reviewer import PRReviewer
+import asyncio
+
+async def run_action():
+    try:
+        pull_request_id = os.environ.get("BITBUCKET_PR_ID", '')
+        slug = os.environ.get("BITBUCKET_REPO_SLUG", '')
+        workspace = os.environ.get("BITBUCKET_WORKSPACE", '')
+        bearer_token = os.environ.get('BITBUCKET_BEARER_TOKEN', None)
+        OPENAI_KEY = os.environ.get('OPENAI_API_KEY') or os.environ.get('OPENAI.KEY')
+        OPENAI_ORG = os.environ.get('OPENAI_ORG') or os.environ.get('OPENAI.ORG')
+        # Check if required environment variables are set
+        if not bearer_token:
+            print("BITBUCKET_BEARER_TOKEN not set")
+            return
+        
+        if not OPENAI_KEY:
+            print("OPENAI_KEY not set")
+            return
+        # Set the environment variables in the settings
+        get_settings().set("BITBUCKET.BEARER_TOKEN", bearer_token)
+        get_settings().set("OPENAI.KEY", OPENAI_KEY)
+        if OPENAI_ORG:
+            get_settings().set("OPENAI.ORG", OPENAI_ORG)
+        if pull_request_id and slug and workspace:
+            pr_url = f"https://bitbucket.org/{workspace}/{slug}/pull-requests/{pull_request_id}"
+            await PRReviewer(pr_url).run()
+    except Exception as e:
+        print(f"An error occurred: {e}")
+if __name__ == "__main__":
+    asyncio.run(run_action())

pr_agent/servers/gerrit_server.py

@@ -1,4 +1,6 @@
 import copy
+import logging
+import sys
 from enum import Enum
 from json import JSONDecodeError
 
@@ -10,10 +12,9 @@ from starlette_context import context
 from starlette_context.middleware import RawContextMiddleware
 
 from pr_agent.agent.pr_agent import PRAgent
-from pr_agent.config_loader import get_settings, global_settings
-from pr_agent.log import get_logger, setup_logger
+from pr_agent.config_loader import global_settings, get_settings
 
-setup_logger()
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 router = APIRouter()
 
 
@@ -34,7 +35,7 @@ class Item(BaseModel):
 
 @router.post("/api/v1/gerrit/{action}")
 async def handle_gerrit_request(action: Action, item: Item):
-    get_logger().debug("Received a Gerrit request")
+    logging.debug("Received a Gerrit request")
     context["settings"] = copy.deepcopy(global_settings)
 
     if action == Action.ask:
@@ -53,7 +54,7 @@ async def get_body(request):
     try:
         body = await request.json()
     except JSONDecodeError as e:
-        get_logger().error("Error parsing request body", e)
+        logging.error("Error parsing request body", e)
         return {}
     return body
 

pr_agent/servers/github_app.py

@@ -1,7 +1,9 @@
 import copy
+import logging
+import sys
 import os
-import asyncio.locks
-from typing import Any, Dict, List, Tuple
+import time
+from typing import Any, Dict
 
 import uvicorn
 from fastapi import APIRouter, FastAPI, HTTPException, Request, Response
@@ -13,13 +15,9 @@ from pr_agent.agent.pr_agent import PRAgent
 from pr_agent.algo.utils import update_settings_from_args
 from pr_agent.config_loader import get_settings, global_settings
 from pr_agent.git_providers import get_git_provider
-from pr_agent.git_providers.utils import apply_repo_settings
-from pr_agent.git_providers.git_provider import IncrementalPR
-from pr_agent.log import LoggingFormat, get_logger, setup_logger
-from pr_agent.servers.utils import verify_signature, DefaultDictWithTimeout
-
-setup_logger(fmt=LoggingFormat.JSON)
+from pr_agent.servers.utils import verify_signature
 
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
 router = APIRouter()
 
 
@@ -30,11 +28,11 @@ async def handle_github_webhooks(request: Request, response: Response):
     Verifies the request signature, parses the request body, and passes it to the handle_request function for further
     processing.
     """
-    get_logger().debug("Received a GitHub webhook")
+    logging.debug("Received a GitHub webhook")
 
     body = await get_body(request)
 
-    get_logger().debug(f'Request body:\n{body}')
+    logging.debug(f'Request body:\n{body}')
     installation_id = body.get("installation", {}).get("id")
     context["installation_id"] = installation_id
     context["settings"] = copy.deepcopy(global_settings)
@@ -46,14 +44,13 @@ async def handle_github_webhooks(request: Request, response: Response):
 @router.post("/api/v1/marketplace_webhooks")
 async def handle_marketplace_webhooks(request: Request, response: Response):
     body = await get_body(request)
-    get_logger().info(f'Request body:\n{body}')
-
+    logging.info(f'Request body:\n{body}')
 
 async def get_body(request):
     try:
         body = await request.json()
     except Exception as e:
-        get_logger().error("Error parsing request body", e)
+        logging.error("Error parsing request body", e)
         raise HTTPException(status_code=400, detail="Error parsing request body") from e
     webhook_secret = getattr(get_settings().github, 'webhook_secret', None)
     if webhook_secret:
@@ -63,9 +60,7 @@ async def get_body(request):
     return body
 
 
-_duplicate_requests_cache = DefaultDictWithTimeout(ttl=get_settings().github_app.duplicate_requests_cache_ttl)
-_duplicate_push_triggers = DefaultDictWithTimeout(ttl=get_settings().github_app.push_trigger_pending_tasks_ttl)
-_pending_task_duplicate_push_conditions = DefaultDictWithTimeout(asyncio.locks.Condition, ttl=get_settings().github_app.push_trigger_pending_tasks_ttl)
+_duplicate_requests_cache = {}
 
 
 async def handle_request(body: Dict[str, Any], event: str):
@@ -81,8 +76,8 @@ async def handle_request(body: Dict[str, Any], event: str):
         return {}
     agent = PRAgent()
     bot_user = get_settings().github_app.bot_user
-    sender = body.get("sender", {}).get("login")
-    log_context = {"action": action, "event": event, "sender": sender, "server_type": "github_app"}
+    logging.info(f"action: '{action}'")
+    logging.info(f"event: '{event}'")
 
     if get_settings().github_app.duplicate_requests_cache and _is_duplicate_request(body):
         return {}
@@ -92,130 +87,56 @@ async def handle_request(body: Dict[str, Any], event: str):
         if "comment" not in body:
             return {}
         comment_body = body.get("comment", {}).get("body")
+        sender = body.get("sender", {}).get("login")
         if sender and bot_user in sender:
-            get_logger().info(f"Ignoring comment from {bot_user} user")
+            logging.info(f"Ignoring comment from {bot_user} user")
             return {}
-        get_logger().info(f"Processing comment from {sender} user")
+        logging.info(f"Processing comment from {sender} user")
         if "issue" in body and "pull_request" in body["issue"] and "url" in body["issue"]["pull_request"]:
             api_url = body["issue"]["pull_request"]["url"]
         elif "comment" in body and "pull_request_url" in body["comment"]:
             api_url = body["comment"]["pull_request_url"]
         else:
             return {}
-        log_context["api_url"] = api_url
-        get_logger().info(body)
-        get_logger().info(f"Handling comment because of event={event} and action={action}")
+        logging.info(body)
+        logging.info(f"Handling comment because of event={event} and action={action}")
         comment_id = body.get("comment", {}).get("id")
         provider = get_git_provider()(pr_url=api_url)
-        with get_logger().contextualize(**log_context):
         await agent.handle_request(api_url, comment_body, notify=lambda: provider.add_eyes_reaction(comment_id))
 
     # handle pull_request event:
     #   automatically review opened/reopened/ready_for_review PRs as long as they're not in draft,
     #   as well as direct review requests from the bot
-    elif event == 'pull_request' and action != 'synchronize':
-        pull_request, api_url = _check_pull_request_event(action, body, log_context, bot_user)
-        if not (pull_request and api_url):
+    elif event == 'pull_request':
+        pull_request = body.get("pull_request")
+        if not pull_request:
+            return {}
+        api_url = pull_request.get("url")
+        if not api_url:
+            return {}
+        if pull_request.get("draft", True) or pull_request.get("state") != "open" or pull_request.get("user", {}).get("login", "") == bot_user:
             return {}
         if action in get_settings().github_app.handle_pr_actions:
             if action == "review_requested":
                 if body.get("requested_reviewer", {}).get("login", "") != bot_user:
                     return {}
-            get_logger().info(f"Performing review for {api_url=} because of {event=} and {action=}")
-            await _perform_commands(get_settings().github_app.pr_commands, agent, body, api_url, log_context)
-
-    # handle pull_request event with synchronize action - "push trigger" for new commits
-    elif event == 'pull_request' and action == 'synchronize' and get_settings().github_app.handle_push_trigger:
-        pull_request, api_url = _check_pull_request_event(action, body, log_context, bot_user)
-        if not (pull_request and api_url):
-            return {}
-
-        # TODO: do we still want to get the list of commits to filter bot/merge commits?
-        before_sha = body.get("before")
-        after_sha = body.get("after")
-        merge_commit_sha = pull_request.get("merge_commit_sha")
-        if before_sha == after_sha:
-            return {}
-        if get_settings().github_app.push_trigger_ignore_merge_commits and after_sha == merge_commit_sha:
-            return {}
-        if get_settings().github_app.push_trigger_ignore_bot_commits and body.get("sender", {}).get("login", "") == bot_user:
-            return {}
-
-        # Prevent triggering multiple times for subsequent push triggers when one is enough:
-        # The first push will trigger the processing, and if there's a second push in the meanwhile it will wait.
-        # Any more events will be discarded, because they will all trigger the exact same processing on the PR.
-        # We let the second event wait instead of discarding it because while the first event was being processed,
-        # more commits may have been pushed that led to the subsequent events,
-        # so we keep just one waiting as a delegate to trigger the processing for the new commits when done waiting.
-        current_active_tasks = _duplicate_push_triggers.setdefault(api_url, 0)
-        max_active_tasks = 2 if get_settings().github_app.push_trigger_pending_tasks_backlog else 1
-        if current_active_tasks < max_active_tasks:
-            # first task can enter, and second tasks too if backlog is enabled
-            get_logger().info(
-                f"Continue processing push trigger for {api_url=} because there are {current_active_tasks} active tasks"
-            )
-            _duplicate_push_triggers[api_url] += 1
-        else:
-            get_logger().info(
-                f"Skipping push trigger for {api_url=} because another event already triggered the same processing"
-            )
-            return {}
-        async with _pending_task_duplicate_push_conditions[api_url]:
-            if current_active_tasks == 1:
-                # second task waits
-                get_logger().info(
-                    f"Waiting to process push trigger for {api_url=} because the first task is still in progress"
-                )
-                await _pending_task_duplicate_push_conditions[api_url].wait()
-                get_logger().info(f"Finished waiting to process push trigger for {api_url=} - continue with flow")
-
-        try:
-            if get_settings().github_app.push_trigger_wait_for_initial_review and not get_git_provider()(api_url, incremental=IncrementalPR(True)).previous_review:
-                get_logger().info(f"Skipping incremental review because there was no initial review for {api_url=} yet")
-                return {}
-            get_logger().info(f"Performing incremental review for {api_url=} because of {event=} and {action=}")
-            await _perform_commands(get_settings().github_app.push_commands, agent, body, api_url, log_context)
-
-        finally:
-            # release the waiting task block
-            async with _pending_task_duplicate_push_conditions[api_url]:
-                _pending_task_duplicate_push_conditions[api_url].notify(1)
-                _duplicate_push_triggers[api_url] -= 1
-
-    get_logger().info("event or action does not require handling")
-    return {}
-
-
-def _check_pull_request_event(action: str, body: dict, log_context: dict, bot_user: str) -> Tuple[Dict[str, Any], str]:
-    invalid_result = {}, ""
-    pull_request = body.get("pull_request")
-    if not pull_request:
-        return invalid_result
-    api_url = pull_request.get("url")
-    if not api_url:
-        return invalid_result
-    log_context["api_url"] = api_url
-    if pull_request.get("draft", True) or pull_request.get("state") != "open" or pull_request.get("user", {}).get("login", "") == bot_user:
-        return invalid_result
-    if action in ("review_requested", "synchronize") and pull_request.get("created_at") == pull_request.get("updated_at"):
+                if pull_request.get("created_at") == pull_request.get("updated_at"):
                     # avoid double reviews when opening a PR for the first time
-        return invalid_result
-    return pull_request, api_url
-
-
-async def _perform_commands(commands: List[str], agent: PRAgent, body: dict, api_url: str, log_context: dict):
-    apply_repo_settings(api_url)
-    for command in commands:
+                    return {}
+            logging.info(f"Performing review because of event={event} and action={action}")
+            for command in get_settings().github_app.pr_commands:
                 split_command = command.split(" ")
                 command = split_command[0]
                 args = split_command[1:]
                 other_args = update_settings_from_args(args)
                 new_command = ' '.join([command] + other_args)
-        get_logger().info(body)
-        get_logger().info(f"Performing command: {new_command}")
-        with get_logger().contextualize(**log_context):
+                logging.info(body)
+                logging.info(f"Performing command: {new_command}")
                 await agent.handle_request(api_url, new_command)
 
+    logging.info("event or action does not require handling")
+    return {}
+
 
 def _is_duplicate_request(body: Dict[str, Any]) -> bool:
     """
@@ -223,11 +144,16 @@ def _is_duplicate_request(body: Dict[str, Any]) -> bool:
     This function checks if the request is duplicate and if so - ignores it.
     """
     request_hash = hash(str(body))
-    get_logger().info(f"request_hash: {request_hash}")
-    is_duplicate = _duplicate_requests_cache.get(request_hash, False)
-    _duplicate_requests_cache[request_hash] = True
+    logging.info(f"request_hash: {request_hash}")
+    request_time = time.monotonic()
+    ttl = get_settings().github_app.duplicate_requests_cache_ttl  # in seconds
+    to_delete = [key for key, key_time in _duplicate_requests_cache.items() if request_time - key_time > ttl]
+    for key in to_delete:
+        del _duplicate_requests_cache[key]
+    is_duplicate = request_hash in _duplicate_requests_cache
+    _duplicate_requests_cache[request_hash] = request_time
     if is_duplicate:
-        get_logger().info(f"Ignoring duplicate request {request_hash}")
+        logging.info(f"Ignoring duplicate request {request_hash}")
     return is_duplicate
 
 

pr_agent/servers/github_polling.py

@@ -1,4 +1,6 @@
 import asyncio
+import logging
+import sys
 from datetime import datetime, timezone
 
 import aiohttp
@@ -6,10 +8,9 @@ import aiohttp
 from pr_agent.agent.pr_agent import PRAgent
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers import get_git_provider
-from pr_agent.log import LoggingFormat, get_logger, setup_logger
 from pr_agent.servers.help import bot_help_text
 
-setup_logger(fmt=LoggingFormat.JSON)
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 NOTIFICATION_URL = "https://api.github.com/notifications"
 
 
@@ -93,7 +94,7 @@ async def polling_loop():
                                             comment_body = comment['body'] if 'body' in comment else ''
                                             commenter_github_user = comment['user']['login'] \
                                                 if 'user' in comment else ''
-                                            get_logger().info(f"Commenter: {commenter_github_user}\nComment: {comment_body}")
+                                            logging.info(f"Commenter: {commenter_github_user}\nComment: {comment_body}")
                                             user_tag = "@" + user_id
                                             if user_tag not in comment_body:
                                                 continue
@@ -111,7 +112,7 @@ async def polling_loop():
                         print(f"Failed to fetch notifications. Status code: {response.status}")
 
             except Exception as e:
-                get_logger().error(f"Exception during processing of a notification: {e}")
+                logging.error(f"Exception during processing of a notification: {e}")
 
 
 if __name__ == '__main__':

pr_agent/servers/gitlab_webhook.py

@@ -1,5 +1,7 @@
 import copy
 import json
+import logging
+import sys
 
 import uvicorn
 from fastapi import APIRouter, FastAPI, Request, status
@@ -12,37 +14,26 @@ from starlette_context.middleware import RawContextMiddleware
 
 from pr_agent.agent.pr_agent import PRAgent
 from pr_agent.config_loader import get_settings, global_settings
-from pr_agent.log import LoggingFormat, get_logger, setup_logger
 from pr_agent.secret_providers import get_secret_provider
 
-setup_logger(fmt=LoggingFormat.JSON)
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
 router = APIRouter()
 
 secret_provider = get_secret_provider() if get_settings().get("CONFIG.SECRET_PROVIDER") else None
 
 
-def handle_request(background_tasks: BackgroundTasks, url: str, body: str, log_context: dict):
-    log_context["action"] = body
-    log_context["event"] = "pull_request" if body == "/review" else "comment"
-    log_context["api_url"] = url
-    with get_logger().contextualize(**log_context):
-        background_tasks.add_task(PRAgent().handle_request, url, body)
-
-
 @router.post("/webhook")
 async def gitlab_webhook(background_tasks: BackgroundTasks, request: Request):
-    log_context = {"server_type": "gitlab_app"}
     if request.headers.get("X-Gitlab-Token") and secret_provider:
         request_token = request.headers.get("X-Gitlab-Token")
         secret = secret_provider.get_secret(request_token)
         try:
             secret_dict = json.loads(secret)
             gitlab_token = secret_dict["gitlab_token"]
-            log_context["sender"] = secret_dict["id"]
             context["settings"] = copy.deepcopy(global_settings)
             context["settings"].gitlab.personal_access_token = gitlab_token
         except Exception as e:
-            get_logger().error(f"Failed to validate secret {request_token}: {e}")
+            logging.error(f"Failed to validate secret {request_token}: {e}")
             return JSONResponse(status_code=status.HTTP_401_UNAUTHORIZED, content=jsonable_encoder({"message": "unauthorized"}))
     elif get_settings().get("GITLAB.SHARED_SECRET"):
         secret = get_settings().get("GITLAB.SHARED_SECRET")
@@ -54,17 +45,17 @@ async def gitlab_webhook(background_tasks: BackgroundTasks, request: Request):
     if not gitlab_token:
         return JSONResponse(status_code=status.HTTP_401_UNAUTHORIZED, content=jsonable_encoder({"message": "unauthorized"}))
     data = await request.json()
-    get_logger().info(json.dumps(data))
+    logging.info(json.dumps(data))
     if data.get('object_kind') == 'merge_request' and data['object_attributes'].get('action') in ['open', 'reopen']:
-        get_logger().info(f"A merge request has been opened: {data['object_attributes'].get('title')}")
+        logging.info(f"A merge request has been opened: {data['object_attributes'].get('title')}")
         url = data['object_attributes'].get('url')
-        handle_request(background_tasks, url, "/review")
+        background_tasks.add_task(PRAgent().handle_request, url, "/review")
     elif data.get('object_kind') == 'note' and data['event_type'] == 'note':
         if 'merge_request' in data:
             mr = data['merge_request']
             url = mr.get('url')
             body = data.get('object_attributes', {}).get('note')
-            handle_request(background_tasks, url, body)
+            background_tasks.add_task(PRAgent().handle_request, url, body)
     return JSONResponse(status_code=status.HTTP_200_OK, content=jsonable_encoder({"message": "success"}))
 
 

pr_agent/servers/serverless.py

@@ -1,10 +1,12 @@
+import logging
+
 from fastapi import FastAPI
 from mangum import Mangum
 
-from pr_agent.log import setup_logger
 from pr_agent.servers.github_app import router
 
-setup_logger()
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)
 
 app = FastAPI()
 app.include_router(router)

pr_agent/servers/utils.py

@@ -1,8 +1,5 @@
 import hashlib
 import hmac
-import time
-from collections import defaultdict
-from typing import Callable, Any
 
 from fastapi import HTTPException
 
@@ -28,59 +25,3 @@ def verify_signature(payload_body, secret_token, signature_header):
 class RateLimitExceeded(Exception):
     """Raised when the git provider API rate limit has been exceeded."""
     pass
-
-
-class DefaultDictWithTimeout(defaultdict):
-    """A defaultdict with a time-to-live (TTL)."""
-
-    def __init__(
-        self,
-        default_factory: Callable[[], Any] = None,
-        ttl: int = None,
-        refresh_interval: int = 60,
-        update_key_time_on_get: bool = True,
-        *args,
-        **kwargs,
-    ):
-        """
-        Args:
-            default_factory: The default factory to use for keys that are not in the dictionary.
-            ttl: The time-to-live (TTL) in seconds.
-            refresh_interval: How often to refresh the dict and delete items older than the TTL.
-            update_key_time_on_get: Whether to update the access time of a key also on get (or only when set).
-        """
-        super().__init__(default_factory, *args, **kwargs)
-        self.__key_times = dict()
-        self.__ttl = ttl
-        self.__refresh_interval = refresh_interval
-        self.__update_key_time_on_get = update_key_time_on_get
-        self.__last_refresh = self.__time() - self.__refresh_interval
-
-    @staticmethod
-    def __time():
-        return time.monotonic()
-
-    def __refresh(self):
-        if self.__ttl is None:
-            return
-        request_time = self.__time()
-        if request_time - self.__last_refresh > self.__refresh_interval:
-            return
-        to_delete = [key for key, key_time in self.__key_times.items() if request_time - key_time > self.__ttl]
-        for key in to_delete:
-            del self[key]
-        self.__last_refresh = request_time
-
-    def __getitem__(self, __key):
-        if self.__update_key_time_on_get:
-            self.__key_times[__key] = self.__time()
-        self.__refresh()
-        return super().__getitem__(__key)
-
-    def __setitem__(self, __key, __value):
-        self.__key_times[__key] = self.__time()
-        return super().__setitem__(__key, __value)
-
-    def __delitem__(self, __key):
-        del self.__key_times[__key]
-        return super().__delitem__(__key)

pr_agent/settings/configuration.toml

@@ -24,7 +24,6 @@ num_code_suggestions=4
 inline_code_comments = false
 ask_and_reflect=false
 automatic_review=true
-remove_previous_review_comment=false
 extra_instructions = ""
 
 [pr_description] # /describe #
@@ -32,7 +31,6 @@ publish_labels=true
 publish_description_as_comment=false
 add_original_user_description=false
 keep_original_user_title=false
-use_bullet_points=true
 extra_instructions = ""
 # markers
 use_description_markers=false
@@ -84,27 +82,6 @@ pr_commands = [
     "/describe --pr_description.add_original_user_description=true --pr_description.keep_original_user_title=true",
     "/auto_review",
 ]
-# settings for "pull_request" event with "synchronize" action - used to detect and handle push triggers for new commits
-handle_push_trigger = false
-push_trigger_ignore_bot_commits = true
-push_trigger_ignore_merge_commits = true
-push_trigger_wait_for_initial_review = true
-push_trigger_pending_tasks_backlog = true
-push_trigger_pending_tasks_ttl = 300
-push_commands = [
-    "/describe --pr_description.add_original_user_description=true --pr_description.keep_original_user_title=true",
-    """/auto_review -i \
-       --pr_reviewer.require_focused_review=false \
-       --pr_reviewer.require_score_review=false \
-       --pr_reviewer.require_tests_review=false \
-       --pr_reviewer.require_security_review=false \
-       --pr_reviewer.require_estimate_effort_to_review=false \
-       --pr_reviewer.num_code_suggestions=0 \
-       --pr_reviewer.inline_code_comments=false \
-       --pr_reviewer.remove_previous_review_comment=true \
-       --pr_reviewer.extra_instructions='' \
-    """
-]
 
 [gitlab]
 # URL to the gitlab service

pr_agent/settings/language_extensions.toml

@@ -433,6 +433,3 @@ reStructuredText = [".rst", ".rest", ".rest.txt", ".rst.txt", ]
 wisp = [".wisp", ]
 xBase = [".prg", ".prw", ]
 
-[docs_blacklist_extensions]
-# Disable docs for these extensions of text files and scripts that are not programming languages of function, classes and methods
-docs_blacklist = ['sql', 'txt', 'yaml', 'json', 'xml', 'md', 'rst', 'rest', 'rest.txt', 'rst.txt', 'mdpolicy', 'mdown', 'markdown', 'mdwn', 'mkd', 'mkdn', 'mkdown', 'sh']

pr_agent/settings/pr_description_prompts.toml

@@ -31,8 +31,7 @@ PR Type:
       - Other
 PR Description:
   type: string
-  description: an informative and concise description of the PR.
-  {%- if use_bullet_points %} Use bullet points. {% endif %}
+  description: an informative and concise description of the PR
 PR Main Files Walkthrough:
   type: array
   maxItems: 10

pr_agent/settings/pr_reviewer_prompts.toml

@@ -25,7 +25,7 @@ code line that already existed in the file....
 The review should focus on new code added in the PR (lines starting with '+'), and not on code that already existed in the file (lines starting with '-', or without prefix).
 
 {%- if num_code_suggestions > 0 %}
-- Provide up to {{ num_code_suggestions }} code suggestions. Try to provide diverse and insightful suggestions.
+- Provide up to {{ num_code_suggestions }} code suggestions.
 - Focus on important suggestions like fixing code problems, issues and bugs. As a second priority, provide suggestions for meaningful code improvements, like performance, vulnerability, modularity, and best practices.
 - Avoid making suggestions that have already been implemented in the PR code. For example, if you want to add logs, or change a variable to const, or anything else, make sure it isn't already in the PR code.
 - Don't suggest to add docstring, type hints, or comments.
@@ -99,10 +99,10 @@ PR Feedback:
   General suggestions:
     type: string
     description: |-
-      General suggestions and feedback for the contributors and maintainers of this PR.
-      May include important suggestions for the overall structure,
-      primary purpose, best practices, critical bugs, and other aspects of the PR.
-      Don't address PR title and description, or lack of tests. Explain your suggestions.
+      General suggestions and feedback for the contributors and maintainers of
+      this PR. May include important suggestions for the overall structure,
+      primary purpose, best practices, critical bugs, and other aspects of the
+      PR. Don't address PR title and description, or lack of tests. Explain your suggestions.
 {%- if num_code_suggestions > 0 %}
   Code feedback:
     type: array
@@ -115,10 +115,11 @@ PR Feedback:
       suggestion:
         type: string
         description: |-
-          a concrete suggestion for meaningfully improving the new PR code.
-          Also describe how, specifically, the suggestion can be applied to new PR code.
-          Add tags with importance measure that matches each suggestion ('important' or 'medium').
-          Do not make suggestions for updating or adding docstrings, renaming PR title and description, or linter like.
+          a concrete suggestion for meaningfully improving the new PR code. Also
+          describe how, specifically, the suggestion can be applied to new PR
+          code. Add tags with importance measure that matches each suggestion
+          ('important' or 'medium'). Do not make suggestions for updating or
+          adding docstrings, renaming PR title and description, or linter like.
       relevant line:
         type: string
         description: |-

pr_agent/tools/pr_add_docs.py

@@ -1,17 +1,16 @@
 import copy
+import logging
 import textwrap
-from typing import Dict
-
+from typing import List, Dict
 from jinja2 import Environment, StrictUndefined
 
 from pr_agent.algo.ai_handler import AiHandler
-from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models, get_pr_multi_diffs
 from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.algo.utils import load_yaml
 from pr_agent.config_loader import get_settings
-from pr_agent.git_providers import get_git_provider
+from pr_agent.git_providers import BitbucketProvider, get_git_provider
 from pr_agent.git_providers.git_provider import get_main_pr_language
-from pr_agent.log import get_logger
 
 
 class PRAddDocs:
@@ -44,39 +43,34 @@ class PRAddDocs:
 
     async def run(self):
         try:
-            get_logger().info('Generating code Docs for PR...')
+            logging.info('Generating code Docs for PR...')
             if get_settings().config.publish_output:
                 self.git_provider.publish_comment("Generating Documentation...", is_temporary=True)
 
-            get_logger().info('Preparing PR documentation...')
+            logging.info('Preparing PR documentation...')
             await retry_with_fallback_models(self._prepare_prediction)
             data = self._prepare_pr_code_docs()
             if (not data) or (not 'Code Documentation' in data):
-                get_logger().info('No code documentation found for PR.')
+                logging.info('No code documentation found for PR.')
                 return
 
             if get_settings().config.publish_output:
-                get_logger().info('Pushing PR documentation...')
+                logging.info('Pushing PR documentation...')
                 self.git_provider.remove_initial_comment()
-                get_logger().info('Pushing inline code documentation...')
+                logging.info('Pushing inline code documentation...')
                 self.push_inline_docs(data)
         except Exception as e:
-            get_logger().error(f"Failed to generate code documentation for PR, error: {e}")
+            logging.error(f"Failed to generate code documentation for PR, error: {e}")
 
     async def _prepare_prediction(self, model: str):
-        get_logger().info('Getting PR diff...')
-
-        # Disable adding docs to scripts and other non-relevant text files
-        from pr_agent.algo.language_handler import bad_extensions
-        bad_extensions += get_settings().docs_blacklist_extensions.docs_blacklist
-
+        logging.info('Getting PR diff...')
         self.patches_diff = get_pr_diff(self.git_provider,
                                         self.token_handler,
                                         model,
                                         add_line_numbers_to_hunks=True,
                                         disable_extra_lines=False)
 
-        get_logger().info('Getting AI prediction...')
+        logging.info('Getting AI prediction...')
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str):
@@ -86,8 +80,8 @@ class PRAddDocs:
         system_prompt = environment.from_string(get_settings().pr_add_docs_prompt.system).render(variables)
         user_prompt = environment.from_string(get_settings().pr_add_docs_prompt.user).render(variables)
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-            get_logger().info(f"\nUser prompt:\n{user_prompt}")
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
         response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
                                                                         system=system_prompt, user=user_prompt)
 
@@ -109,7 +103,7 @@ class PRAddDocs:
         for d in data['Code Documentation']:
             try:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().info(f"add_docs: {d}")
+                    logging.info(f"add_docs: {d}")
                 relevant_file = d['relevant file'].strip()
                 relevant_line = int(d['relevant line'])  # absolute position
                 documentation = d['documentation']
@@ -124,11 +118,11 @@ class PRAddDocs:
                                              'relevant_lines_end': relevant_line})
             except Exception:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().info(f"Could not parse code docs: {d}")
+                    logging.info(f"Could not parse code docs: {d}")
 
         is_successful = self.git_provider.publish_code_suggestions(docs)
         if not is_successful:
-            get_logger().info("Failed to publish code docs, trying to publish each docs separately")
+            logging.info("Failed to publish code docs, trying to publish each docs separately")
             for doc_suggestion in docs:
                 self.git_provider.publish_code_suggestions([doc_suggestion])
 
@@ -160,7 +154,7 @@ class PRAddDocs:
                         new_code_snippet = new_code_snippet.rstrip() + "\n" + original_initial_line
         except Exception as e:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Could not dedent code snippet for file {relevant_file}, error: {e}")
+                logging.info(f"Could not dedent code snippet for file {relevant_file}, error: {e}")
 
         return new_code_snippet
 

pr_agent/tools/pr_code_suggestions.py

@@ -1,17 +1,16 @@
 import copy
+import logging
 import textwrap
-from typing import Dict, List
-
+from typing import List, Dict
 from jinja2 import Environment, StrictUndefined
 
 from pr_agent.algo.ai_handler import AiHandler
-from pr_agent.algo.pr_processing import get_pr_diff, get_pr_multi_diffs, retry_with_fallback_models
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models, get_pr_multi_diffs
 from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.algo.utils import load_yaml
 from pr_agent.config_loader import get_settings
-from pr_agent.git_providers import get_git_provider
+from pr_agent.git_providers import BitbucketProvider, get_git_provider
 from pr_agent.git_providers.git_provider import get_main_pr_language
-from pr_agent.log import get_logger
 
 
 class PRCodeSuggestions:
@@ -53,42 +52,42 @@ class PRCodeSuggestions:
 
     async def run(self):
         try:
-            get_logger().info('Generating code suggestions for PR...')
+            logging.info('Generating code suggestions for PR...')
             if get_settings().config.publish_output:
                 self.git_provider.publish_comment("Preparing review...", is_temporary=True)
 
-            get_logger().info('Preparing PR review...')
+            logging.info('Preparing PR review...')
             if not self.is_extended:
                 await retry_with_fallback_models(self._prepare_prediction)
                 data = self._prepare_pr_code_suggestions()
             else:
                 data = await retry_with_fallback_models(self._prepare_prediction_extended)
             if (not data) or (not 'Code suggestions' in data):
-                get_logger().info('No code suggestions found for PR.')
+                logging.info('No code suggestions found for PR.')
                 return
 
             if (not self.is_extended and get_settings().pr_code_suggestions.rank_suggestions) or \
                     (self.is_extended and get_settings().pr_code_suggestions.rank_extended_suggestions):
-                get_logger().info('Ranking Suggestions...')
+                logging.info('Ranking Suggestions...')
                 data['Code suggestions'] = await self.rank_suggestions(data['Code suggestions'])
 
             if get_settings().config.publish_output:
-                get_logger().info('Pushing PR review...')
+                logging.info('Pushing PR review...')
                 self.git_provider.remove_initial_comment()
-                get_logger().info('Pushing inline code suggestions...')
+                logging.info('Pushing inline code suggestions...')
                 self.push_inline_code_suggestions(data)
         except Exception as e:
-            get_logger().error(f"Failed to generate code suggestions for PR, error: {e}")
+            logging.error(f"Failed to generate code suggestions for PR, error: {e}")
 
     async def _prepare_prediction(self, model: str):
-        get_logger().info('Getting PR diff...')
+        logging.info('Getting PR diff...')
         self.patches_diff = get_pr_diff(self.git_provider,
                                         self.token_handler,
                                         model,
                                         add_line_numbers_to_hunks=True,
                                         disable_extra_lines=True)
 
-        get_logger().info('Getting AI prediction...')
+        logging.info('Getting AI prediction...')
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str):
@@ -98,8 +97,8 @@ class PRCodeSuggestions:
         system_prompt = environment.from_string(get_settings().pr_code_suggestions_prompt.system).render(variables)
         user_prompt = environment.from_string(get_settings().pr_code_suggestions_prompt.user).render(variables)
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-            get_logger().info(f"\nUser prompt:\n{user_prompt}")
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
         response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
                                                                         system=system_prompt, user=user_prompt)
 
@@ -121,7 +120,7 @@ class PRCodeSuggestions:
         for d in data['Code suggestions']:
             try:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().info(f"suggestion: {d}")
+                    logging.info(f"suggestion: {d}")
                 relevant_file = d['relevant file'].strip()
                 relevant_lines_start = int(d['relevant lines start'])  # absolute position
                 relevant_lines_end = int(d['relevant lines end'])
@@ -137,11 +136,11 @@ class PRCodeSuggestions:
                                          'relevant_lines_end': relevant_lines_end})
             except Exception:
                 if get_settings().config.verbosity_level >= 2:
-                    get_logger().info(f"Could not parse suggestion: {d}")
+                    logging.info(f"Could not parse suggestion: {d}")
 
         is_successful = self.git_provider.publish_code_suggestions(code_suggestions)
         if not is_successful:
-            get_logger().info("Failed to publish code suggestions, trying to publish each suggestion separately")
+            logging.info("Failed to publish code suggestions, trying to publish each suggestion separately")
             for code_suggestion in code_suggestions:
                 self.git_provider.publish_code_suggestions([code_suggestion])
 
@@ -163,19 +162,19 @@ class PRCodeSuggestions:
                     new_code_snippet = textwrap.indent(new_code_snippet, delta_spaces * " ").rstrip('\n')
         except Exception as e:
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"Could not dedent code snippet for file {relevant_file}, error: {e}")
+                logging.info(f"Could not dedent code snippet for file {relevant_file}, error: {e}")
 
         return new_code_snippet
 
     async def _prepare_prediction_extended(self, model: str) -> dict:
-        get_logger().info('Getting PR diff...')
+        logging.info('Getting PR diff...')
         patches_diff_list = get_pr_multi_diffs(self.git_provider, self.token_handler, model,
                                                max_calls=get_settings().pr_code_suggestions.max_number_of_calls)
 
-        get_logger().info('Getting multi AI predictions...')
+        logging.info('Getting multi AI predictions...')
         prediction_list = []
         for i, patches_diff in enumerate(patches_diff_list):
-            get_logger().info(f"Processing chunk {i + 1} of {len(patches_diff_list)}")
+            logging.info(f"Processing chunk {i + 1} of {len(patches_diff_list)}")
             self.patches_diff = patches_diff
             prediction = await self._get_prediction(model)
             prediction_list.append(prediction)
@@ -223,8 +222,8 @@ class PRCodeSuggestions:
                 variables)
             user_prompt = environment.from_string(get_settings().pr_sort_code_suggestions_prompt.user).render(variables)
             if get_settings().config.verbosity_level >= 2:
-                get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-                get_logger().info(f"\nUser prompt:\n{user_prompt}")
+                logging.info(f"\nSystem prompt:\n{system_prompt}")
+                logging.info(f"\nUser prompt:\n{user_prompt}")
             response, finish_reason = await self.ai_handler.chat_completion(model=model, system=system_prompt,
                                                                             user=user_prompt)
 
@@ -239,7 +238,7 @@ class PRCodeSuggestions:
                 data_sorted = data_sorted[:new_len]
         except Exception as e:
             if get_settings().config.verbosity_level >= 1:
-                get_logger().info(f"Could not sort suggestions, error: {e}")
+                logging.info(f"Could not sort suggestions, error: {e}")
             data_sorted = suggestion_list
 
         return data_sorted

pr_agent/tools/pr_config.py

@@ -1,6 +1,7 @@
+import logging
+
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers import get_git_provider
-from pr_agent.log import get_logger
 
 
 class PRConfig:
@@ -18,11 +19,11 @@ class PRConfig:
         self.git_provider = get_git_provider()(pr_url)
 
     async def run(self):
-        get_logger().info('Getting configuration settings...')
-        get_logger().info('Preparing configs...')
+        logging.info('Getting configuration settings...')
+        logging.info('Preparing configs...')
         pr_comment = self._prepare_pr_configs()
         if get_settings().config.publish_output:
-            get_logger().info('Pushing configs...')
+            logging.info('Pushing configs...')
             self.git_provider.publish_comment(pr_comment)
             self.git_provider.remove_initial_comment()
         return ""
@@ -43,5 +44,5 @@ class PRConfig:
                 comment_str += f"\n{header.lower()}.{key.lower()} = {repr(value) if isinstance(value, str) else value}"
                 comment_str += "  "
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"comment_str:\n{comment_str}")
+            logging.info(f"comment_str:\n{comment_str}")
         return comment_str

pr_agent/tools/pr_description.py

@@ -1,5 +1,7 @@
 import copy
+import json
 import re
+import logging
 from typing import List, Tuple
 
 from jinja2 import Environment, StrictUndefined
@@ -11,7 +13,6 @@ from pr_agent.algo.utils import load_yaml
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers import get_git_provider
 from pr_agent.git_providers.git_provider import get_main_pr_language
-from pr_agent.log import get_logger
 
 
 class PRDescription:
@@ -40,7 +41,6 @@ class PRDescription:
             "description": self.git_provider.get_pr_description(full=False),
             "language": self.main_pr_language,
             "diff": "",  # empty diff for initial calculation
-            "use_bullet_points": get_settings().pr_description.use_bullet_points,
             "extra_instructions": get_settings().pr_description.extra_instructions,
             "commit_messages_str": self.git_provider.get_commit_messages()
         }
@@ -65,13 +65,13 @@ class PRDescription:
         """
 
         try:
-            get_logger().info(f"Generating a PR description {self.pr_id}")
+            logging.info(f"Generating a PR description {self.pr_id}")
             if get_settings().config.publish_output:
                 self.git_provider.publish_comment("Preparing PR description...", is_temporary=True)
 
             await retry_with_fallback_models(self._prepare_prediction)
 
-            get_logger().info(f"Preparing answer {self.pr_id}")
+            logging.info(f"Preparing answer {self.pr_id}")
             if self.prediction:
                 self._prepare_data()
             else:
@@ -88,7 +88,7 @@ class PRDescription:
             full_markdown_description = f"## Title\n\n{pr_title}\n\n___\n{pr_body}"
 
             if get_settings().config.publish_output:
-                get_logger().info(f"Pushing answer {self.pr_id}")
+                logging.info(f"Pushing answer {self.pr_id}")
                 if get_settings().pr_description.publish_description_as_comment:
                     self.git_provider.publish_comment(full_markdown_description)
                 else:
@@ -100,7 +100,7 @@ class PRDescription:
                         self.git_provider.publish_labels(pr_labels + current_labels)
                 self.git_provider.remove_initial_comment()
         except Exception as e:
-            get_logger().error(f"Error generating PR description {self.pr_id}: {e}")
+            logging.error(f"Error generating PR description {self.pr_id}: {e}")
         
         return ""
 
@@ -121,9 +121,9 @@ class PRDescription:
         if get_settings().pr_description.use_description_markers and 'pr_agent:' not in self.user_description:
             return None
 
-        get_logger().info(f"Getting PR diff {self.pr_id}")
+        logging.info(f"Getting PR diff {self.pr_id}")
         self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
-        get_logger().info(f"Getting AI prediction {self.pr_id}")
+        logging.info(f"Getting AI prediction {self.pr_id}")
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str) -> str:
@@ -144,8 +144,8 @@ class PRDescription:
         user_prompt = environment.from_string(get_settings().pr_description_prompt.user).render(variables)
 
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-            get_logger().info(f"\nUser prompt:\n{user_prompt}")
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
 
         response, finish_reason = await self.ai_handler.chat_completion(
             model=model,
@@ -178,7 +178,7 @@ class PRDescription:
         return pr_types
 
     def _prepare_pr_answer_with_markers(self) -> Tuple[str, str]:
-        get_logger().info(f"Using description marker replacements {self.pr_id}")
+        logging.info(f"Using description marker replacements {self.pr_id}")
         title = self.vars["title"]
         body = self.user_description
         if get_settings().pr_description.include_generated_by_header:
@@ -186,11 +186,6 @@ class PRDescription:
         else:
             ai_header = ""
 
-        ai_type = self.data.get('PR Type')
-        if ai_type and not re.search(r'<!--\s*pr_agent:type\s*-->', body):
-            pr_type = f"{ai_header}{ai_type}"
-            body = body.replace('pr_agent:type', pr_type)
-
         ai_summary = self.data.get('PR Description')
         if ai_summary and not re.search(r'<!--\s*pr_agent:summary\s*-->', body):
             summary = f"{ai_header}{ai_summary}"
@@ -257,6 +252,6 @@ class PRDescription:
                 pr_body += "\n___\n"
 
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"title:\n{title}\n{pr_body}")
+            logging.info(f"title:\n{title}\n{pr_body}")
 
         return title, pr_body

pr_agent/tools/pr_information_from_user.py

@@ -1,4 +1,5 @@
 import copy
+import logging
 
 from jinja2 import Environment, StrictUndefined
 
@@ -8,7 +9,6 @@ from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers import get_git_provider
 from pr_agent.git_providers.git_provider import get_main_pr_language
-from pr_agent.log import get_logger
 
 
 class PRInformationFromUser:
@@ -34,22 +34,22 @@ class PRInformationFromUser:
         self.prediction = None
 
     async def run(self):
-        get_logger().info('Generating question to the user...')
+        logging.info('Generating question to the user...')
         if get_settings().config.publish_output:
             self.git_provider.publish_comment("Preparing questions...", is_temporary=True)
         await retry_with_fallback_models(self._prepare_prediction)
-        get_logger().info('Preparing questions...')
+        logging.info('Preparing questions...')
         pr_comment = self._prepare_pr_answer()
         if get_settings().config.publish_output:
-            get_logger().info('Pushing questions...')
+            logging.info('Pushing questions...')
             self.git_provider.publish_comment(pr_comment)
             self.git_provider.remove_initial_comment()
         return ""
 
     async def _prepare_prediction(self, model):
-        get_logger().info('Getting PR diff...')
+        logging.info('Getting PR diff...')
         self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
-        get_logger().info('Getting AI prediction...')
+        logging.info('Getting AI prediction...')
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str):
@@ -59,8 +59,8 @@ class PRInformationFromUser:
         system_prompt = environment.from_string(get_settings().pr_information_from_user_prompt.system).render(variables)
         user_prompt = environment.from_string(get_settings().pr_information_from_user_prompt.user).render(variables)
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-            get_logger().info(f"\nUser prompt:\n{user_prompt}")
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
         response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
                                                                         system=system_prompt, user=user_prompt)
         return response
@@ -68,7 +68,7 @@ class PRInformationFromUser:
     def _prepare_pr_answer(self) -> str:
         model_output = self.prediction.strip()
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"answer_str:\n{model_output}")
+            logging.info(f"answer_str:\n{model_output}")
         answer_str = f"{model_output}\n\n Please respond to the questions above in the following format:\n\n" +\
                      "\n>/answer\n>1) ...\n>2) ...\n>...\n"
         return answer_str

pr_agent/tools/pr_questions.py

@@ -1,4 +1,5 @@
 import copy
+import logging
 
 from jinja2 import Environment, StrictUndefined
 
@@ -8,7 +9,6 @@ from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers import get_git_provider
 from pr_agent.git_providers.git_provider import get_main_pr_language
-from pr_agent.log import get_logger
 
 
 class PRQuestions:
@@ -44,22 +44,22 @@ class PRQuestions:
         return question_str
 
     async def run(self):
-        get_logger().info('Answering a PR question...')
+        logging.info('Answering a PR question...')
         if get_settings().config.publish_output:
             self.git_provider.publish_comment("Preparing answer...", is_temporary=True)
         await retry_with_fallback_models(self._prepare_prediction)
-        get_logger().info('Preparing answer...')
+        logging.info('Preparing answer...')
         pr_comment = self._prepare_pr_answer()
         if get_settings().config.publish_output:
-            get_logger().info('Pushing answer...')
+            logging.info('Pushing answer...')
             self.git_provider.publish_comment(pr_comment)
             self.git_provider.remove_initial_comment()
         return ""
 
     async def _prepare_prediction(self, model: str):
-        get_logger().info('Getting PR diff...')
+        logging.info('Getting PR diff...')
         self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
-        get_logger().info('Getting AI prediction...')
+        logging.info('Getting AI prediction...')
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str):
@@ -69,8 +69,8 @@ class PRQuestions:
         system_prompt = environment.from_string(get_settings().pr_questions_prompt.system).render(variables)
         user_prompt = environment.from_string(get_settings().pr_questions_prompt.user).render(variables)
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-            get_logger().info(f"\nUser prompt:\n{user_prompt}")
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
         response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
                                                                         system=system_prompt, user=user_prompt)
         return response
@@ -79,5 +79,5 @@ class PRQuestions:
         answer_str = f"Question: {self.question_str}\n\n"
         answer_str += f"Answer:\n{self.prediction.strip()}\n\n"
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"answer_str:\n{answer_str}")
+            logging.info(f"answer_str:\n{answer_str}")
         return answer_str

pr_agent/tools/pr_reviewer.py

@@ -1,4 +1,6 @@
 import copy
+import json
+import logging
 from collections import OrderedDict
 from typing import List, Tuple
 
@@ -7,13 +9,13 @@ from jinja2 import Environment, StrictUndefined
 from yaml import SafeLoader
 
 from pr_agent.algo.ai_handler import AiHandler
-from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models, \
+    find_line_number_of_relevant_line_in_file, clip_tokens
 from pr_agent.algo.token_handler import TokenHandler
-from pr_agent.algo.utils import convert_to_markdown, load_yaml, try_fix_yaml
+from pr_agent.algo.utils import convert_to_markdown, try_fix_json, try_fix_yaml, load_yaml
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers import get_git_provider
 from pr_agent.git_providers.git_provider import IncrementalPR, get_main_pr_language
-from pr_agent.log import get_logger
 from pr_agent.servers.help import actions_help_text, bot_help_text
 
 
@@ -96,33 +98,29 @@ class PRReviewer:
 
         try:
             if self.is_auto and not get_settings().pr_reviewer.automatic_review:
-                get_logger().info(f'Automatic review is disabled {self.pr_url}')
-                return None
-            if self.is_auto and self.incremental.is_incremental and not self.incremental.first_new_commit_sha:
-                get_logger().info(f"Incremental review is enabled for {self.pr_url} but there are no new commits")
+                logging.info(f'Automatic review is disabled {self.pr_url}')
                 return None
 
-            get_logger().info(f'Reviewing PR: {self.pr_url} ...')
+            logging.info(f'Reviewing PR: {self.pr_url} ...')
 
             if get_settings().config.publish_output:
                 self.git_provider.publish_comment("Preparing review...", is_temporary=True)
 
             await retry_with_fallback_models(self._prepare_prediction)
 
-            get_logger().info('Preparing PR review...')
+            logging.info('Preparing PR review...')
             pr_comment = self._prepare_pr_review()
 
             if get_settings().config.publish_output:
-                get_logger().info('Pushing PR review...')
-                previous_review_comment = self._get_previous_review_comment()
+                logging.info('Pushing PR review...')
                 self.git_provider.publish_comment(pr_comment)
                 self.git_provider.remove_initial_comment()
-                self._remove_previous_review_comment(previous_review_comment)
+
                 if get_settings().pr_reviewer.inline_code_comments:
-                    get_logger().info('Pushing inline code comments...')
+                    logging.info('Pushing inline code comments...')
                     self._publish_inline_code_comments()
         except Exception as e:
-            get_logger().error(f"Failed to review PR: {e}")
+            logging.error(f"Failed to review PR: {e}")
 
     async def _prepare_prediction(self, model: str) -> None:
         """
@@ -134,9 +132,9 @@ class PRReviewer:
         Returns:
             None
         """
-        get_logger().info('Getting PR diff...')
+        logging.info('Getting PR diff...')
         self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
-        get_logger().info('Getting AI prediction...')
+        logging.info('Getting AI prediction...')
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str) -> str:
@@ -157,8 +155,8 @@ class PRReviewer:
         user_prompt = environment.from_string(get_settings().pr_review_prompt.user).render(variables)
 
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-            get_logger().info(f"\nUser prompt:\n{user_prompt}")
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
 
         response, finish_reason = await self.ai_handler.chat_completion(
             model=model,
@@ -232,13 +230,9 @@ class PRReviewer:
         if self.incremental.is_incremental:
             last_commit_url = f"{self.git_provider.get_pr_url()}/commits/" \
                               f"{self.git_provider.incremental.first_new_commit_sha}"
-            last_commit_msg = self.incremental.commits_range[0].commit.message if self.incremental.commits_range else ""
-            incremental_review_markdown_text = f"Starting from commit {last_commit_url}"
-            if last_commit_msg:
-                incremental_review_markdown_text += f"  \n_({last_commit_msg.splitlines(keepends=False)[0]})_"
             data = OrderedDict(data)
             data.update({'Incremental PR Review': {
-                "⏮️ Review for commits since previous PR-Agent review": incremental_review_markdown_text}})
+                "⏮️ Review for commits since previous PR-Agent review": f"Starting from commit {last_commit_url}"}})
             data.move_to_end('Incremental PR Review', last=False)
 
         markdown_text = convert_to_markdown(data, self.git_provider.is_supported("gfm_markdown"))
@@ -255,7 +249,7 @@ class PRReviewer:
 
         # Log markdown response if verbosity level is high
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"Markdown response:\n{markdown_text}")
+            logging.info(f"Markdown response:\n{markdown_text}")
 
         if markdown_text == None or len(markdown_text) == 0:
             markdown_text = ""
@@ -274,7 +268,7 @@ class PRReviewer:
         try:
             data = yaml.load(review_text, Loader=SafeLoader)
         except Exception as e:
-            get_logger().error(f"Failed to parse AI prediction: {e}")
+            logging.error(f"Failed to parse AI prediction: {e}")
             data = try_fix_yaml(review_text)
 
         comments: List[str] = []
@@ -283,7 +277,7 @@ class PRReviewer:
             relevant_line_in_file = suggestion.get('relevant line', '').strip()
             content = suggestion.get('suggestion', '')
             if not relevant_file or not relevant_line_in_file or not content:
-                get_logger().info("Skipping inline comment with missing file/line/content")
+                logging.info("Skipping inline comment with missing file/line/content")
                 continue
 
             if self.git_provider.is_supported("create_inline_comment"):
@@ -319,26 +313,3 @@ class PRReviewer:
                     break
 
         return question_str, answer_str
-
-    def _get_previous_review_comment(self):
-        """
-        Get the previous review comment if it exists.
-        """
-        try:
-            if get_settings().pr_reviewer.remove_previous_review_comment and hasattr(self.git_provider, "get_previous_review"):
-                return self.git_provider.get_previous_review(
-                    full=not self.incremental.is_incremental,
-                    incremental=self.incremental.is_incremental,
-                )
-        except Exception as e:
-            get_logger().exception(f"Failed to get previous review comment, error: {e}")
-
-    def _remove_previous_review_comment(self, comment):
-        """
-        Remove the previous review comment if it exists.
-        """
-        try:
-            if get_settings().pr_reviewer.remove_previous_review_comment and comment:
-                self.git_provider.remove_comment(comment)
-        except Exception as e:
-            get_logger().exception(f"Failed to remove previous review comment, error: {e}")

pr_agent/tools/pr_similar_issue.py

@@ -1,18 +1,18 @@
-import time
+import copy
+import json
+import logging
 from enum import Enum
-from typing import List
-
+from typing import List, Tuple
+import pinecone
 import openai
 import pandas as pd
-import pinecone
-from pinecone_datasets import Dataset, DatasetMetadata
 from pydantic import BaseModel, Field
 
 from pr_agent.algo import MAX_TOKENS
 from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers import get_git_provider
-from pr_agent.log import get_logger
+from pinecone_datasets import Dataset, DatasetMetadata
 
 MODEL = "text-embedding-ada-002"
 
@@ -47,13 +47,6 @@ class PRSimilarIssue:
 
         # check if index exists, and if repo is already indexed
         run_from_scratch = False
-        if run_from_scratch:  # for debugging
-            pinecone.init(api_key=api_key, environment=environment)
-            if index_name in pinecone.list_indexes():
-                get_logger().info('Removing index...')
-                pinecone.delete_index(index_name)
-                get_logger().info('Done')
-
         upsert = True
         pinecone.init(api_key=api_key, environment=environment)
         if not index_name in pinecone.list_indexes():
@@ -69,11 +62,11 @@ class PRSimilarIssue:
                     upsert = False
 
         if run_from_scratch or upsert:  # index the entire repo
-            get_logger().info('Indexing the entire repo...')
+            logging.info('Indexing the entire repo...')
 
-            get_logger().info('Getting issues...')
+            logging.info('Getting issues...')
             issues = list(repo_obj.get_issues(state='all'))
-            get_logger().info('Done')
+            logging.info('Done')
             self._update_index_with_issues(issues, repo_name_for_index, upsert=upsert)
         else:  # update index if needed
             pinecone_index = pinecone.Index(index_name=index_name)
@@ -99,20 +92,20 @@ class PRSimilarIssue:
                     break
 
             if issues_to_update:
-                get_logger().info(f'Updating index with {counter} new issues...')
+                logging.info(f'Updating index with {counter} new issues...')
                 self._update_index_with_issues(issues_to_update, repo_name_for_index, upsert=True)
             else:
-                get_logger().info('No new issues to update')
+                logging.info('No new issues to update')
 
     async def run(self):
-        get_logger().info('Getting issue...')
+        logging.info('Getting issue...')
         repo_name, original_issue_number = self.git_provider._parse_issue_url(self.issue_url.split('=')[-1])
         issue_main = self.git_provider.repo_obj.get_issue(original_issue_number)
         issue_str, comments, number = self._process_issue(issue_main)
         openai.api_key = get_settings().openai.key
-        get_logger().info('Done')
+        logging.info('Done')
 
-        get_logger().info('Querying...')
+        logging.info('Querying...')
         res = openai.Embedding.create(input=[issue_str], engine=MODEL)
         embeds = [record['embedding'] for record in res['data']]
         pinecone_index = pinecone.Index(index_name=self.index_name)
@@ -124,16 +117,7 @@ class PRSimilarIssue:
         relevant_comment_number_list = []
         score_list = []
         for r in res['matches']:
-            # skip example issue
-            if 'example_issue_' in r["id"]:
-                continue
-
-            try:
             issue_number = int(r["id"].split('.')[0].split('_')[-1])
-            except:
-                get_logger().debug(f"Failed to parse issue number from {r['id']}")
-                continue
-
             if original_issue_number == issue_number:
                 continue
             if issue_number not in relevant_issues_number_list:
@@ -143,9 +127,9 @@ class PRSimilarIssue:
             else:
                 relevant_comment_number_list.append(-1)
             score_list.append(str("{:.2f}".format(r['score'])))
-        get_logger().info('Done')
+        logging.info('Done')
 
-        get_logger().info('Publishing response...')
+        logging.info('Publishing response...')
         similar_issues_str = "### Similar Issues\n___\n\n"
         for i, issue_number_similar in enumerate(relevant_issues_number_list):
             issue = self.git_provider.repo_obj.get_issue(issue_number_similar)
@@ -156,8 +140,8 @@ class PRSimilarIssue:
             similar_issues_str += f"{i + 1}. **[{title}]({url})** (score={score_list[i]})\n\n"
         if get_settings().config.publish_output:
             response = issue_main.create_comment(similar_issues_str)
-        get_logger().info(similar_issues_str)
-        get_logger().info('Done')
+        logging.info(similar_issues_str)
+        logging.info('Done')
 
     def _process_issue(self, issue):
         header = issue.title
@@ -171,7 +155,7 @@ class PRSimilarIssue:
         return issue_str, comments, number
 
     def _update_index_with_issues(self, issues_list, repo_name_for_index, upsert=False):
-        get_logger().info('Processing issues...')
+        logging.info('Processing issues...')
         corpus = Corpus()
         example_issue_record = Record(
             id=f"example_issue_{repo_name_for_index}",
@@ -187,9 +171,9 @@ class PRSimilarIssue:
 
             counter += 1
             if counter % 100 == 0:
-                get_logger().info(f"Scanned {counter} issues")
+                logging.info(f"Scanned {counter} issues")
             if counter >= self.max_issues_to_scan:
-                get_logger().info(f"Scanned {self.max_issues_to_scan} issues, stopping")
+                logging.info(f"Scanned {self.max_issues_to_scan} issues, stopping")
                 break
 
             issue_str, comments, number = self._process_issue(issue)
@@ -226,9 +210,9 @@ class PRSimilarIssue:
                             )
                             corpus.append(comment_record)
         df = pd.DataFrame(corpus.dict()["documents"])
-        get_logger().info('Done')
+        logging.info('Done')
 
-        get_logger().info('Embedding...')
+        logging.info('Embedding...')
         openai.api_key = get_settings().openai.key
         list_to_encode = list(df["text"].values)
         try:
@@ -236,7 +220,7 @@ class PRSimilarIssue:
             embeds = [record['embedding'] for record in res['data']]
         except:
             embeds = []
-            get_logger().error('Failed to embed entire list, embedding one by one...')
+            logging.error('Failed to embed entire list, embedding one by one...')
             for i, text in enumerate(list_to_encode):
                 try:
                     res = openai.Embedding.create(input=[text], engine=MODEL)
@@ -247,23 +231,21 @@ class PRSimilarIssue:
         meta = DatasetMetadata.empty()
         meta.dense_model.dimension = len(embeds[0])
         ds = Dataset.from_pandas(df, meta)
-        get_logger().info('Done')
+        logging.info('Done')
 
         api_key = get_settings().pinecone.api_key
         environment = get_settings().pinecone.environment
         if not upsert:
-            get_logger().info('Creating index from scratch...')
+            logging.info('Creating index from scratch...')
             ds.to_pinecone_index(self.index_name, api_key=api_key, environment=environment)
-            time.sleep(15)  # wait for pinecone to finalize indexing before querying
         else:
-            get_logger().info('Upserting index...')
+            logging.info('Upserting index...')
             namespace = ""
             batch_size: int = 100
             concurrency: int = 10
             pinecone.init(api_key=api_key, environment=environment)
             ds._upsert_to_index(self.index_name, namespace, batch_size, concurrency)
-            time.sleep(5)  # wait for pinecone to finalize upserting before querying
-        get_logger().info('Done')
+        logging.info('Done')
 
 
 class IssueLevel(str, Enum):

pr_agent/tools/pr_update_changelog.py

@@ -1,4 +1,5 @@
 import copy
+import logging
 from datetime import date
 from time import sleep
 from typing import Tuple
@@ -9,9 +10,8 @@ from pr_agent.algo.ai_handler import AiHandler
 from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
 from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.config_loader import get_settings
-from pr_agent.git_providers import get_git_provider
+from pr_agent.git_providers import GithubProvider, get_git_provider
 from pr_agent.git_providers.git_provider import get_main_pr_language
-from pr_agent.log import get_logger
 
 CHANGELOG_LINES = 50
 
@@ -48,26 +48,26 @@ class PRUpdateChangelog:
     async def run(self):
         # assert type(self.git_provider) == GithubProvider, "Currently only Github is supported"
 
-        get_logger().info('Updating the changelog...')
+        logging.info('Updating the changelog...')
         if get_settings().config.publish_output:
             self.git_provider.publish_comment("Preparing changelog updates...", is_temporary=True)
         await retry_with_fallback_models(self._prepare_prediction)
-        get_logger().info('Preparing PR changelog updates...')
+        logging.info('Preparing PR changelog updates...')
         new_file_content, answer = self._prepare_changelog_update()
         if get_settings().config.publish_output:
             self.git_provider.remove_initial_comment()
-            get_logger().info('Publishing changelog updates...')
+            logging.info('Publishing changelog updates...')
             if self.commit_changelog:
-                get_logger().info('Pushing PR changelog updates to repo...')
+                logging.info('Pushing PR changelog updates to repo...')
                 self._push_changelog_update(new_file_content, answer)
             else:
-                get_logger().info('Publishing PR changelog as comment...')
+                logging.info('Publishing PR changelog as comment...')
                 self.git_provider.publish_comment(f"**Changelog updates:**\n\n{answer}")
 
     async def _prepare_prediction(self, model: str):
-        get_logger().info('Getting PR diff...')
+        logging.info('Getting PR diff...')
         self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
-        get_logger().info('Getting AI prediction...')
+        logging.info('Getting AI prediction...')
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str):
@@ -77,8 +77,8 @@ class PRUpdateChangelog:
         system_prompt = environment.from_string(get_settings().pr_update_changelog_prompt.system).render(variables)
         user_prompt = environment.from_string(get_settings().pr_update_changelog_prompt.user).render(variables)
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"\nSystem prompt:\n{system_prompt}")
-            get_logger().info(f"\nUser prompt:\n{user_prompt}")
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
         response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
                                                                         system=system_prompt, user=user_prompt)
 
@@ -100,7 +100,7 @@ class PRUpdateChangelog:
                       "\n>'/update_changelog --pr_update_changelog.push_changelog_changes=true'\n"
 
         if get_settings().config.verbosity_level >= 2:
-            get_logger().info(f"answer:\n{answer}")
+            logging.info(f"answer:\n{answer}")
 
         return new_file_content, answer
 
@@ -149,7 +149,7 @@ Example:
         except Exception:
             self.changelog_file_str = ""
             if self.commit_changelog:
-                get_logger().info("No CHANGELOG.md file found in the repository. Creating one...")
+                logging.info("No CHANGELOG.md file found in the repository. Creating one...")
                 changelog_file = self.git_provider.repo_obj.create_file(path="CHANGELOG.md",
                                                                              message='add CHANGELOG.md',
                                                                              content="",

requirements.txt

@@ -21,4 +21,3 @@ azure-devops==7.1.0b3
 msrest==0.7.1
 pinecone-client
 pinecone-datasets @ git+https://github.com/mrT23/pinecone-datasets.git@main
-loguru==0.7.2

tests/unittest/test_handle_patch_deletions.py

@@ -43,6 +43,18 @@ class TestHandlePatchDeletions:
         assert handle_patch_deletions(patch, original_file_content_str, new_file_content_str,
                                       file_name) == patch.rstrip()
 
+    # Tests that handle_patch_deletions logs a message when verbosity_level is greater than 0
+    def test_handle_patch_deletions_happy_path_verbosity_level_greater_than_0(self, caplog):
+        patch = '--- a/file.py\n+++ b/file.py\n@@ -1,2 +1,2 @@\n-foo\n-bar\n+baz\n'
+        original_file_content_str = 'foo\nbar\n'
+        new_file_content_str = ''
+        file_name = 'file.py'
+        get_settings().config.verbosity_level = 1
+
+        with caplog.at_level(logging.INFO):
+            handle_patch_deletions(patch, original_file_content_str, new_file_content_str, file_name)
+            assert any("Processing file" in message for message in caplog.messages)
+
     # Tests that handle_patch_deletions returns 'File was deleted' when new_file_content_str is empty
     def test_handle_patch_deletions_edge_case_new_file_content_empty(self):
         patch = '--- a/file.py\n+++ b/file.py\n@@ -1,2 +1,2 @@\n-foo\n-bar\n'