pr-agent 0.2.0__py3-none-any.whl

pr_agent/__init__.py

@@ -0,0 +1 @@
+

pr_agent/agent/pr_agent.py

@@ -0,0 +1,94 @@
+import shlex
+from functools import partial
+
+from pr_agent.algo.ai_handlers.base_ai_handler import BaseAiHandler
+from pr_agent.algo.ai_handlers.litellm_ai_handler import LiteLLMAIHandler
+
+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.log import get_logger
+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_generate_labels import PRGenerateLabels
+from pr_agent.tools.pr_help_message import PRHelpMessage
+from pr_agent.tools.pr_information_from_user import PRInformationFromUser
+from pr_agent.tools.pr_line_questions import PR_LineQuestions
+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
+
+command2class = {
+    "auto_review": PRReviewer,
+    "answer": PRReviewer,
+    "review": PRReviewer,
+    "review_pr": PRReviewer,
+    "reflect": PRInformationFromUser,
+    "reflect_and_review": PRInformationFromUser,
+    "describe": PRDescription,
+    "describe_pr": PRDescription,
+    "improve": PRCodeSuggestions,
+    "improve_code": PRCodeSuggestions,
+    "ask": PRQuestions,
+    "ask_question": PRQuestions,
+    "ask_line": PR_LineQuestions,
+    "update_changelog": PRUpdateChangelog,
+    "config": PRConfig,
+    "settings": PRConfig,
+    "help": PRHelpMessage,
+    "similar_issue": PRSimilarIssue,
+    "add_docs": PRAddDocs,
+    "generate_labels": PRGenerateLabels,
+}
+
+commands = list(command2class.keys())
+
+class PRAgent:
+    def __init__(self, ai_handler: partial[BaseAiHandler,] = LiteLLMAIHandler):
+        self.ai_handler = ai_handler # will be initialized in run_action
+        self.forbidden_cli_args = ['enable_auto_approval']
+
+    async def handle_request(self, pr_url, request, notify=None) -> bool:
+        # First, apply repo specific settings if exists
+        apply_repo_settings(pr_url)
+
+        # Then, apply user specific settings if exists
+        if isinstance(request, str):
+            request = request.replace("'", "\\'")
+            lexer = shlex.shlex(request, posix=True)
+            lexer.whitespace_split = True
+            action, *args = list(lexer)
+        else:
+            action, *args = request
+
+        if args:
+            for forbidden_arg in self.forbidden_cli_args:
+                for arg in args:
+                    if forbidden_arg in arg:
+                        get_logger().error(f"CLI argument for param '{forbidden_arg}' is forbidden. Use instead a configuration file.")
+                        return False
+        args = update_settings_from_args(args)
+
+        action = action.lstrip("/").lower()
+        with get_logger().contextualize(command=action):
+            get_logger().info("PR-Agent request handler started", analytics=True)
+            if action == "reflect_and_review":
+                get_settings().pr_reviewer.ask_and_reflect = True
+            if action == "answer":
+                if notify:
+                    notify()
+                await PRReviewer(pr_url, is_answer=True, args=args, ai_handler=self.ai_handler).run()
+            elif action == "auto_review":
+                await PRReviewer(pr_url, is_auto=True, args=args, ai_handler=self.ai_handler).run()
+            elif action in command2class:
+                if notify:
+                    notify()
+
+                await command2class[action](pr_url, ai_handler=self.ai_handler, args=args).run()
+            else:
+                return False
+            return True
+

pr_agent/algo/__init__.py

@@ -0,0 +1,31 @@
+MAX_TOKENS = {
+    'text-embedding-ada-002': 8000,
+    'gpt-3.5-turbo': 4000,
+    'gpt-3.5-turbo-0613': 4000,
+    'gpt-3.5-turbo-0301': 4000,
+    'gpt-3.5-turbo-16k': 16000,
+    'gpt-3.5-turbo-16k-0613': 16000,
+    'gpt-4': 8000,
+    'gpt-4-0613': 8000,
+    'gpt-4-32k': 32000,
+    'gpt-4-1106-preview': 128000, # 128K, but may be limited by config.max_model_tokens
+    'gpt-4-0125-preview': 128000,  # 128K, but may be limited by config.max_model_tokens
+    'claude-instant-1': 100000,
+    'claude-2': 100000,
+    'command-nightly': 4096,
+    'replicate/llama-2-70b-chat:2c1608e18606fad2812020dc541930f2d0495ce32eee50074220b87300bc16e1': 4096,
+    'meta-llama/Llama-2-7b-chat-hf': 4096,
+    'vertex_ai/codechat-bison': 6144,
+    'vertex_ai/codechat-bison-32k': 32000,
+    'codechat-bison': 6144,
+    'codechat-bison-32k': 32000,
+    'anthropic.claude-instant-v1': 100000,
+    'anthropic.claude-v1': 100000,
+    'anthropic.claude-v2': 100000,
+    'anthropic/claude-3-opus-20240229': 100000,
+    'bedrock/anthropic.claude-instant-v1': 100000,
+    'bedrock/anthropic.claude-v2': 100000,
+    'bedrock/anthropic.claude-v2:1': 100000,
+    'bedrock/anthropic.claude-3-sonnet-20240229-v1:0': 100000,
+    'bedrock/anthropic.claude-3-haiku-20240307-v1:0': 100000,
+}

pr_agent/algo/ai_handlers/base_ai_handler.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+
+class BaseAiHandler(ABC):
+    """
+    This class defines the interface for an AI handler to be used by the PR Agents.  
+    """
+
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @property
+    @abstractmethod
+    def deployment_id(self):
+        pass
+
+    @abstractmethod   
+    async def chat_completion(self, model: str, system: str, user: str, temperature: float = 0.2):
+        """
+        This method should be implemented to return a chat completion from the AI model.
+        Args:
+            model (str): the name of the model to use for the chat completion
+            system (str): the system message string to use for the chat completion
+            user (str): the user message string to use for the chat completion
+            temperature (float): the temperature to use for the chat completion    
+        """
+        pass
+

pr_agent/algo/ai_handlers/langchain_ai_handler.py

@@ -0,0 +1,67 @@
+try:
+    from langchain.chat_models import ChatOpenAI, AzureChatOpenAI
+    from langchain.schema import SystemMessage, HumanMessage
+except: # we don't enforce langchain as a dependency, so if it's not installed, just move on
+    pass
+
+from pr_agent.algo.ai_handlers.base_ai_handler import BaseAiHandler
+from pr_agent.config_loader import get_settings
+from pr_agent.log import get_logger
+
+from openai.error import APIError, RateLimitError, Timeout, TryAgain
+from retry import retry
+import functools
+
+OPENAI_RETRIES = 5
+
+class LangChainOpenAIHandler(BaseAiHandler):
+    def __init__(self):
+        # Initialize OpenAIHandler specific attributes here
+        super().__init__()
+        self.azure = get_settings().get("OPENAI.API_TYPE", "").lower() == "azure"
+        try:
+            if self.azure:
+                # using a partial function so we can set the deployment_id later to support fallback_deployments
+                # but still need to access the other settings now so we can raise a proper exception if they're missing
+                self._chat = functools.partial(
+                    lambda **kwargs: AzureChatOpenAI(**kwargs),
+                    openai_api_key=get_settings().openai.key,
+                    openai_api_base=get_settings().openai.api_base,
+                    openai_api_version=get_settings().openai.api_version,
+                )
+            else:
+                self._chat = ChatOpenAI(openai_api_key=get_settings().openai.key)
+        except AttributeError as e:
+            if getattr(e, "name"):
+                raise ValueError(f"OpenAI {e.name} is required") from e
+            else:
+                raise e
+    
+    @property
+    def chat(self):
+        if self.azure:
+            # we must set the deployment_id only here (instead of the __init__ method) to support fallback_deployments
+            return self._chat(deployment_name=self.deployment_id)
+        else:
+            return self._chat
+
+    @property
+    def deployment_id(self):
+        """
+        Returns the deployment ID for the OpenAI API.
+        """
+        return get_settings().get("OPENAI.DEPLOYMENT_ID", None)
+    @retry(exceptions=(APIError, Timeout, TryAgain, AttributeError, RateLimitError),
+           tries=OPENAI_RETRIES, delay=2, backoff=2, jitter=(1, 3))
+    async def chat_completion(self, model: str, system: str, user: str, temperature: float = 0.2):
+        try:
+            messages=[SystemMessage(content=system), HumanMessage(content=user)]
+            
+            # get a chat completion from the formatted messages
+            resp = self.chat(messages, model=model, temperature=temperature)
+            finish_reason="completed"
+            return resp.content, finish_reason
+        
+        except (Exception) as e:
+            get_logger().error("Unknown error during OpenAI inference: ", e)
+            raise e

pr_agent/algo/ai_handlers/litellm_ai_handler.py

@@ -0,0 +1,153 @@
+import os
+
+import boto3
+import litellm
+import openai
+from litellm import acompletion
+from tenacity import retry, retry_if_exception_type, stop_after_attempt
+from pr_agent.algo.ai_handlers.base_ai_handler import BaseAiHandler
+from pr_agent.config_loader import get_settings
+from pr_agent.log import get_logger
+
+OPENAI_RETRIES = 5
+
+
+class LiteLLMAIHandler(BaseAiHandler):
+    """
+    This class handles interactions with the OpenAI API for chat completions.
+    It initializes the API key and other settings from a configuration file,
+    and provides a method for performing chat completions using the OpenAI ChatCompletion API.
+    """
+
+    def __init__(self):
+        """
+        Initializes the OpenAI API key and other settings from a configuration file.
+        Raises a ValueError if the OpenAI key is missing.
+        """
+        self.azure = False
+        self.aws_bedrock_client = None
+        self.api_base = None
+        self.repetition_penalty = None
+        if get_settings().get("OPENAI.KEY", None):
+            openai.api_key = get_settings().openai.key
+            litellm.openai_key = get_settings().openai.key
+        if get_settings().get("litellm.use_client"):
+            litellm_token = get_settings().get("litellm.LITELLM_TOKEN")
+            assert litellm_token, "LITELLM_TOKEN is required"
+            os.environ["LITELLM_TOKEN"] = litellm_token
+            litellm.use_client = True
+        if get_settings().get("LITELLM.DROP_PARAMS", None):
+            litellm.drop_params = get_settings().litellm.drop_params
+        if get_settings().get("OPENAI.ORG", None):
+            litellm.organization = get_settings().openai.org
+        if get_settings().get("OPENAI.API_TYPE", None):
+            if get_settings().openai.api_type == "azure":
+                self.azure = True
+                litellm.azure_key = get_settings().openai.key
+        if get_settings().get("OPENAI.API_VERSION", None):
+            litellm.api_version = get_settings().openai.api_version
+        if get_settings().get("OPENAI.API_BASE", None):
+            litellm.api_base = get_settings().openai.api_base
+        if get_settings().get("ANTHROPIC.KEY", None):
+            litellm.anthropic_key = get_settings().anthropic.key
+        if get_settings().get("COHERE.KEY", None):
+            litellm.cohere_key = get_settings().cohere.key
+        if get_settings().get("REPLICATE.KEY", None):
+            litellm.replicate_key = get_settings().replicate.key
+        if get_settings().get("REPLICATE.KEY", None):
+            litellm.replicate_key = get_settings().replicate.key
+        if get_settings().get("HUGGINGFACE.KEY", None):
+            litellm.huggingface_key = get_settings().huggingface.key
+        if get_settings().get("HUGGINGFACE.API_BASE", None) and 'huggingface' in get_settings().config.model:
+            litellm.api_base = get_settings().huggingface.api_base
+            self.api_base = get_settings().huggingface.api_base
+        if get_settings().get("HUGGINGFACE.REPITITION_PENALTY", None):
+            self.repetition_penalty = float(get_settings().huggingface.repetition_penalty)
+        if get_settings().get("VERTEXAI.VERTEX_PROJECT", None):
+            litellm.vertex_project = get_settings().vertexai.vertex_project
+            litellm.vertex_location = get_settings().get(
+                "VERTEXAI.VERTEX_LOCATION", None
+            )
+        if get_settings().get("AWS.BEDROCK_REGION", None):
+            litellm.AmazonAnthropicConfig.max_tokens_to_sample = 2000
+            litellm.AmazonAnthropicClaude3Config.max_tokens = 2000
+            self.aws_bedrock_client = boto3.client(
+                service_name="bedrock-runtime",
+                region_name=get_settings().aws.bedrock_region,
+            )
+
+    def prepare_logs(self, response, system, user, resp, finish_reason):
+        response_log = response.dict().copy()
+        response_log['system'] = system
+        response_log['user'] = user
+        response_log['output'] = resp
+        response_log['finish_reason'] = finish_reason
+        if hasattr(self, 'main_pr_language'):
+            response_log['main_pr_language'] = self.main_pr_language
+        else:
+            response_log['main_pr_language'] = 'unknown'
+        return response_log
+
+    @property
+    def deployment_id(self):
+        """
+        Returns the deployment ID for the OpenAI API.
+        """
+        return get_settings().get("OPENAI.DEPLOYMENT_ID", None)
+
+    @retry(
+        retry=retry_if_exception_type((openai.APIError, openai.APIConnectionError, openai.Timeout)), # No retry on RateLimitError
+        stop=stop_after_attempt(OPENAI_RETRIES)
+    )
+    async def chat_completion(self, model: str, system: str, user: str, temperature: float = 0.2):
+        try:
+            resp, finish_reason = None, None
+            deployment_id = self.deployment_id
+            if self.azure:
+                model = 'azure/' + model
+            messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
+            kwargs = {
+                "model": model,
+                "deployment_id": deployment_id,
+                "messages": messages,
+                "temperature": temperature,
+                "force_timeout": get_settings().config.ai_timeout,
+                "api_base" : self.api_base,
+            }
+            if self.aws_bedrock_client:
+                kwargs["aws_bedrock_client"] = self.aws_bedrock_client
+            if self.repetition_penalty:
+                kwargs["repetition_penalty"] = self.repetition_penalty
+
+            get_logger().debug("Prompts", artifact={"system": system, "user": user})
+
+            if get_settings().config.verbosity_level >= 2:
+                get_logger().info(f"\nSystem prompt:\n{system}")
+                get_logger().info(f"\nUser prompt:\n{user}")
+
+            response = await acompletion(**kwargs)
+        except (openai.APIError, openai.Timeout) as e:
+            get_logger().error("Error during OpenAI inference: ", e)
+            raise
+        except (openai.RateLimitError) as e:
+            get_logger().error("Rate limit error during OpenAI inference: ", e)
+            raise
+        except (Exception) as e:
+            get_logger().error("Unknown error during OpenAI inference: ", e)
+            raise openai.APIError from e
+        if response is None or len(response["choices"]) == 0:
+            raise openai.APIError
+        else:
+            resp = response["choices"][0]['message']['content']
+            finish_reason = response["choices"][0]["finish_reason"]
+            get_logger().debug(f"\nAI response:\n{resp}")
+
+            # log the full response for debugging
+            response_log = self.prepare_logs(response, system, user, resp, finish_reason)
+            get_logger().debug("Full_response", artifact=response_log)
+
+            # for CLI debugging
+            if get_settings().config.verbosity_level >= 2:
+                get_logger().info(f"\nAI response:\n{resp}")
+
+        return resp, finish_reason

pr_agent/algo/ai_handlers/openai_ai_handler.py

@@ -0,0 +1,67 @@
+from pr_agent.algo.ai_handlers.base_ai_handler import BaseAiHandler
+import openai
+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
+
+
+class OpenAIHandler(BaseAiHandler):
+    def __init__(self):
+        # Initialize OpenAIHandler specific attributes here
+        try:
+            super().__init__()
+            openai.api_key = get_settings().openai.key
+            if get_settings().get("OPENAI.ORG", None):
+                openai.organization = get_settings().openai.org
+            if get_settings().get("OPENAI.API_TYPE", None):
+                if get_settings().openai.api_type == "azure":
+                    self.azure = True
+                    openai.azure_key = get_settings().openai.key
+            if get_settings().get("OPENAI.API_VERSION", None):
+                openai.api_version = get_settings().openai.api_version
+            if get_settings().get("OPENAI.API_BASE", None):
+                openai.api_base = get_settings().openai.api_base
+
+        except AttributeError as e:
+            raise ValueError("OpenAI key is required") from e
+    @property
+    def deployment_id(self):
+        """
+        Returns the deployment ID for the OpenAI API.
+        """
+        return get_settings().get("OPENAI.DEPLOYMENT_ID", None)
+    
+    @retry(exceptions=(APIError, Timeout, TryAgain, AttributeError, RateLimitError),
+           tries=OPENAI_RETRIES, delay=2, backoff=2, jitter=(1, 3))
+    async def chat_completion(self, model: str, system: str, user: str, temperature: float = 0.2):
+        try:
+            deployment_id = self.deployment_id
+            get_logger().info("System: ", system)
+            get_logger().info("User: ", user)
+            messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+            chat_completion = await openai.ChatCompletion.acreate(
+                model=model,
+                deployment_id=deployment_id,
+                messages=messages,
+                temperature=temperature,
+            )
+            resp = chat_completion["choices"][0]['message']['content']
+            finish_reason = chat_completion["choices"][0]["finish_reason"]
+            usage = chat_completion.get("usage")
+            get_logger().info("AI response", response=resp, messages=messages, finish_reason=finish_reason,
+                            model=model, usage=usage)
+            return resp, finish_reason       
+        except (APIError, Timeout, TryAgain) as e:
+            get_logger().error("Error during OpenAI inference: ", e)
+            raise
+        except (RateLimitError) as e:
+            get_logger().error("Rate limit error during OpenAI inference: ", e)
+            raise
+        except (Exception) as e:
+            get_logger().error("Unknown error during OpenAI inference: ", e)
+            raise TryAgain from e        

pr_agent/algo/file_filter.py

@@ -0,0 +1,36 @@
+import fnmatch
+import re
+
+from pr_agent.config_loader import get_settings
+
+def filter_ignored(files):
+    """
+    Filter out files that match the ignore patterns.
+    """
+
+    try:
+        # load regex patterns, and translate glob patterns to regex
+        patterns = get_settings().ignore.regex
+        if isinstance(patterns, str):
+            patterns = [patterns]
+        glob_setting = get_settings().ignore.glob
+        if isinstance(glob_setting, str): # --ignore.glob=[.*utils.py], --ignore.glob=.*utils.py
+            glob_setting = glob_setting.strip('[]').split(",")
+        patterns += [fnmatch.translate(glob) for glob in glob_setting]
+
+        # compile all valid patterns
+        compiled_patterns = []
+        for r in patterns:
+            try:
+                compiled_patterns.append(re.compile(r))
+            except re.error:
+                pass
+
+        # keep filenames that _don't_ match the ignore regex
+        for r in compiled_patterns:
+            files = [f for f in files if (f.filename and not r.match(f.filename))]
+
+    except Exception as e:
+        print(f"Could not filter file list: {e}")
+
+    return files