agentr 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

agentr/application.py

@@ -35,8 +35,8 @@ class APIApplication(Application):
             response.raise_for_status()
             return response
         except NotAuthorizedError as e:
-            logger.warning(f"Reddit authorization needed: {e.message}")
-            return e.message 
+            logger.warning(f"Authorization needed: {e.message}")
+            raise e
         except Exception as e:
             logger.error(f"Error getting {url}: {e}")
             raise e
@@ -49,8 +49,8 @@ class APIApplication(Application):
             response.raise_for_status()
             return response
         except NotAuthorizedError as e:
-            logger.warning(f"Reddit authorization needed: {e.message}")
-            return e.message 
+            logger.warning(f"Authorization needed: {e.message}")
+            raise e
         except httpx.HTTPStatusError as e:
             if e.response.status_code == 429:
                 return e.response.text or "Rate limit exceeded. Please try again later."
@@ -67,8 +67,8 @@ class APIApplication(Application):
             response.raise_for_status()
             return response
         except NotAuthorizedError as e:
-            logger.warning(f"Reddit authorization needed: {e.message}")
-            return e.message 
+            logger.warning(f"Authorization needed: {e.message}")
+            raise e
         except Exception as e:
             logger.error(f"Error posting {url}: {e}")
             raise e
@@ -80,10 +80,11 @@ class APIApplication(Application):
             response.raise_for_status()
             return response
         except NotAuthorizedError as e:
-            logger.warning(f"Reddit authorization needed: {e.message}")
-            return e.message 
+            logger.warning(f"Authorization needed: {e.message}")
+            raise e
         except Exception as e:
             logger.error(f"Error posting {url}: {e}")
+            raise e
 
     def validate(self):
         pass

agentr/applications/github/app.py

@@ -1,7 +1,6 @@
 from agentr.integration import Integration
 from agentr.application import APIApplication
 from loguru import logger
-from agentr.exceptions import NotAuthorizedError
 
 class GithubApp(APIApplication):
     def __init__(self, integration: Integration) -> None:
@@ -12,10 +11,6 @@ class GithubApp(APIApplication):
         if not self.integration:
             raise ValueError("Integration not configured")
         credentials = self.integration.get_credentials()
-        if not credentials:
-            logger.warning("No credentials found")
-            action = self.integration.authorize()
-            raise NotAuthorizedError(action)
         if "headers" in credentials:
             return credentials["headers"]
         return {
@@ -55,35 +50,24 @@ class GithubApp(APIApplication):
         Returns:
             A formatted list of recent commits
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/commits"
-            response = self._get(url)
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/commits"
+        response = self._get(url)
+        response.raise_for_status()
+        
+        commits = response.json()
+        if not commits:
+            return f"No commits found for repository {repo_full_name}"
+        
+        result = f"Recent commits for {repo_full_name}:\n\n"
+        for commit in commits[:12]:  # Limit to 12 commits 
+            sha = commit.get("sha", "")[:7]
+            message = commit.get("commit", {}).get("message", "").split('\n')[0]
+            author = commit.get("commit", {}).get("author", {}).get("name", "Unknown")
             
-            if response.status_code == 200:
-                commits = response.json()
-                if not commits:
-                    return f"No commits found for repository {repo_full_name}"
-                
-                result = f"Recent commits for {repo_full_name}:\n\n"
-                for commit in commits[:12]:  # Limit to 12 commits 
-                    sha = commit.get("sha", "")[:7]
-                    message = commit.get("commit", {}).get("message", "").split('\n')[0]
-                    author = commit.get("commit", {}).get("author", {}).get("name", "Unknown")
-                    
-                    result += f"- {sha}: {message} (by {author})\n"
-                
-                return result
-            elif response.status_code == 404:
-                return f"Repository {repo_full_name} not found"
-            else:
-                logger.error(response.text)
-                return f"Error retrieving commits: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error retrieving commits: {str(e)}"
+            result += f"- {sha}: {message} (by {author})\n"
+        
+        return result
 
     def list_branches(self, repo_full_name: str) -> str:
         """List branches for a GitHub repository
@@ -94,32 +78,21 @@ class GithubApp(APIApplication):
         Returns:
             A formatted list of branches
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/branches"
-            response = self._get(url)
-            
-            if response.status_code == 200:
-                branches = response.json()
-                if not branches:
-                    return f"No branches found for repository {repo_full_name}"
-                
-                result = f"Branches for {repo_full_name}:\n\n"
-                for branch in branches:
-                    branch_name = branch.get("name", "Unknown")
-                    result += f"- {branch_name}\n"
-                
-                return result
-            elif response.status_code == 404:
-                return f"Repository {repo_full_name} not found"
-            else:
-                logger.error(response.text)
-                return f"Error retrieving branches: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error retrieving branches: {str(e)}"
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/branches"
+        response = self._get(url)
+        response.raise_for_status()
+        
+        branches = response.json()
+        if not branches:
+            return f"No branches found for repository {repo_full_name}"
+        
+        result = f"Branches for {repo_full_name}:\n\n"
+        for branch in branches:
+            branch_name = branch.get("name", "Unknown")
+            result += f"- {branch_name}\n"
+        
+        return result
     
     def list_pull_requests(self, repo_full_name: str, state: str = "open") -> str:
         """List pull requests for a GitHub repository
@@ -131,37 +104,26 @@ class GithubApp(APIApplication):
         Returns:
             A formatted list of pull requests
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/pulls"
-            params = {"state": state}
-            response = self._get(url, params=params)
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/pulls"
+        params = {"state": state}
+        response = self._get(url, params=params)
+        response.raise_for_status()
+        
+        pull_requests = response.json()
+        if not pull_requests:
+            return f"No pull requests found for repository {repo_full_name} with state '{state}'"
+        
+        result = f"Pull requests for {repo_full_name} (State: {state}):\n\n"
+        for pr in pull_requests:
+            pr_title = pr.get("title", "No Title")
+            pr_number = pr.get("number", "Unknown")
+            pr_state = pr.get("state", "Unknown")
+            pr_user = pr.get("user", {}).get("login", "Unknown")
             
-            if response.status_code == 200:
-                pull_requests = response.json()
-                if not pull_requests:
-                    return f"No pull requests found for repository {repo_full_name} with state '{state}'"
-                
-                result = f"Pull requests for {repo_full_name} (State: {state}):\n\n"
-                for pr in pull_requests:
-                    pr_title = pr.get("title", "No Title")
-                    pr_number = pr.get("number", "Unknown")
-                    pr_state = pr.get("state", "Unknown")
-                    pr_user = pr.get("user", {}).get("login", "Unknown")
-                    
-                    result += f"- PR #{pr_number}: {pr_title} (by {pr_user}, Status: {pr_state})\n"
-                
-                return result
-            elif response.status_code == 404:
-                return f"Repository {repo_full_name} not found"
-            else:
-                logger.error(response.text)
-                return f"Error retrieving pull requests: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error retrieving pull requests: {str(e)}"
+            result += f"- PR #{pr_number}: {pr_title} (by {pr_user}, Status: {pr_state})\n"
+        
+        return result
 
     def list_issues(self, repo_full_name: str, per_page: int = 30, page: int = 1) -> str:
         """List issues for a GitHub repository
@@ -174,40 +136,29 @@ class GithubApp(APIApplication):
         Returns:
             A formatted list of issues
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/issues/events"
-            params = {
-                "per_page": per_page,
-                "page": page
-            }
-            response = self._get(url, params=params)
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/issues/events"
+        params = {
+            "per_page": per_page,
+            "page": page
+        }
+        response = self._get(url, params=params)
+        response.raise_for_status()
+        
+        issues = response.json()
+        if not issues:
+            return f"No issues found for repository {repo_full_name}"
+        
+        result = f"Issues for {repo_full_name} (Page {page}):\n\n"
+        for issue in issues:
+            issue_title = issue.get("issue", {}).get("title", "No Title")
+            issue_number = issue.get("issue", {}).get("number", "Unknown")
+            issue_state = issue.get("issue", {}).get("state", "Unknown")
+            issue_user = issue.get("issue", {}).get("user", {}).get("login", "Unknown")
             
-            if response.status_code == 200:
-                issues = response.json()
-                if not issues:
-                    return f"No issues found for repository {repo_full_name}"
-                
-                result = f"Issues for {repo_full_name} (Page {page}):\n\n"
-                for issue in issues:
-                    issue_title = issue.get("issue", {}).get("title", "No Title")
-                    issue_number = issue.get("issue", {}).get("number", "Unknown")
-                    issue_state = issue.get("issue", {}).get("state", "Unknown")
-                    issue_user = issue.get("issue", {}).get("user", {}).get("login", "Unknown")
-                    
-                    result += f"- Issue #{issue_number}: {issue_title} (by {issue_user}, Status: {issue_state})\n"
-                
-                return result
-            elif response.status_code == 404:
-                return f"Repository {repo_full_name} not found"
-            else:
-                logger.error(response.text)
-                return f"Error retrieving issues: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error retrieving issues: {str(e)}"
+            result += f"- Issue #{issue_number}: {issue_title} (by {issue_user}, Status: {issue_state})\n"
+        
+        return result
 
     def get_pull_request(self, repo_full_name: str, pull_number: int) -> str:
         """Get a specific pull request for a GitHub repository
@@ -219,37 +170,26 @@ class GithubApp(APIApplication):
         Returns:
             A formatted string with pull request details
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/pulls/{pull_number}"
-            response = self._get(url)
-            
-            if response.status_code == 200:
-                pr = response.json()
-                pr_title = pr.get("title", "No Title")
-                pr_number = pr.get("number", "Unknown")
-                pr_state = pr.get("state", "Unknown")
-                pr_user = pr.get("user", {}).get("login", "Unknown")
-                pr_body = pr.get("body", "No description provided.")
-                
-                result = (
-                    f"Pull Request #{pr_number}: {pr_title}\n"
-                    f"Created by: {pr_user}\n"
-                    f"Status: {pr_state}\n"
-                    f"Description: {pr_body}\n"
-                )
-                
-                return result
-            elif response.status_code == 404:
-                return f"Pull request #{pull_number} not found in repository {repo_full_name}"
-            else:
-                logger.error(response.text)
-                return f"Error retrieving pull request: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error retrieving pull request: {str(e)}"
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/pulls/{pull_number}"
+        response = self._get(url)
+        response.raise_for_status()
+        
+        pr = response.json()
+        pr_title = pr.get("title", "No Title")
+        pr_number = pr.get("number", "Unknown")
+        pr_state = pr.get("state", "Unknown")
+        pr_user = pr.get("user", {}).get("login", "Unknown")
+        pr_body = pr.get("body", "No description provided.")
+        
+        result = (
+            f"Pull Request #{pr_number}: {pr_title}\n"
+            f"Created by: {pr_user}\n"
+            f"Status: {pr_state}\n"
+            f"Description: {pr_body}\n"
+        )
+        
+        return result
 
     def create_pull_request(self, repo_full_name: str, title: str, head: str, base: str, body: str = "", 
                             maintainer_can_modify: bool = True, draft: bool = False) -> str:
@@ -267,38 +207,29 @@ class GithubApp(APIApplication):
         Returns:
             A confirmation message with the new pull request details
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/pulls"
-            
-            pull_request_data = {
-                "title": title,
-                "head": head,
-                "base": base,
-                "body": body,
-                "maintainer_can_modify": maintainer_can_modify,
-                "draft": draft
-            }
-            
-            response = self._post(url, pull_request_data)
-            
-            if response.status_code in [200, 201]:
-                pr = response.json()
-                pr_number = pr.get("number", "Unknown")
-                pr_url = pr.get("html_url", "")
-                
-                return f"Successfully created pull request #{pr_number}:\n" \
-                       f"Title: {title}\n" \
-                       f"From: {head} → To: {base}\n" \
-                       f"URL: {pr_url}"
-            else:
-                logger.error(response.text)
-                return f"Error creating pull request: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error creating pull request: {str(e)}"
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/pulls"
+        
+        pull_request_data = {
+            "title": title,
+            "head": head,
+            "base": base,
+            "body": body,
+            "maintainer_can_modify": maintainer_can_modify,
+            "draft": draft
+        }
+        
+        response = self._post(url, pull_request_data)
+        response.raise_for_status()
+        
+        pr = response.json()
+        pr_number = pr.get("number", "Unknown")
+        pr_url = pr.get("html_url", "")
+        
+        return f"Successfully created pull request #{pr_number}:\n" \
+               f"Title: {title}\n" \
+               f"From: {head} → To: {base}\n" \
+               f"URL: {pr_url}"
 
     def create_issue(self, repo_full_name: str, title: str, body: str = "", labels = None) -> str:
         """Create a new issue in a GitHub repository
@@ -315,40 +246,31 @@ class GithubApp(APIApplication):
         Returns:
             A confirmation message with the new issue details
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/issues"
-            
-            issue_data = {
-                "title": title,
-                "body": body
-            }
-            
-            if labels:
-                if isinstance(labels, str):
-                    labels_list = [label.strip() for label in labels.split(",") if label.strip()]
-                    issue_data["labels"] = labels_list
-                else:
-                    issue_data["labels"] = labels
-            
-            response = self._post(url, issue_data)
-            
-            if response.status_code in [200, 201]:
-                issue = response.json()
-                issue_number = issue.get("number", "Unknown")
-                issue_url = issue.get("html_url", "")
-                
-                return f"Successfully created issue #{issue_number}:\n" \
-                       f"Title: {title}\n" \
-                       f"URL: {issue_url}"
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/issues"
+        
+        issue_data = {
+            "title": title,
+            "body": body
+        }
+        
+        if labels:
+            if isinstance(labels, str):
+                labels_list = [label.strip() for label in labels.split(",") if label.strip()]
+                issue_data["labels"] = labels_list
             else:
-                logger.error(response.text)
-                return f"Error creating issue: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error creating issue: {str(e)}"
+                issue_data["labels"] = labels
+        
+        response = self._post(url, issue_data)
+        response.raise_for_status()
+        
+        issue = response.json()
+        issue_number = issue.get("number", "Unknown")
+        issue_url = issue.get("html_url", "")
+        
+        return f"Successfully created issue #{issue_number}:\n" \
+               f"Title: {title}\n" \
+               f"URL: {issue_url}"
 
     def list_repo_activities(self, repo_full_name: str, direction: str = "desc", per_page: int = 30) -> str:
         """List activities for a GitHub repository
@@ -361,46 +283,35 @@ class GithubApp(APIApplication):
         Returns:
             A formatted list of repository activities
         """
-        try:
-            repo_full_name = repo_full_name.strip()
-            url = f"{self.base_api_url}/{repo_full_name}/activity"
-            
-            # Build query parameters
-            params = {
-                "direction": direction,
-                "per_page": per_page
-            }
-            
-            response = self._get(url, params=params)
+        repo_full_name = repo_full_name.strip()
+        url = f"{self.base_api_url}/{repo_full_name}/activity"
+        
+        # Build query parameters
+        params = {
+            "direction": direction,
+            "per_page": per_page
+        }
+        
+        response = self._get(url, params=params)
+        response.raise_for_status()
+        
+        activities = response.json()
+        if not activities:
+            return f"No activities found for repository {repo_full_name}"
+        
+        result = f"Repository activities for {repo_full_name}:\n\n"
+        
+        for activity in activities:
+            # Extract common fields
+            timestamp = activity.get("timestamp", "Unknown time")
+            actor_name = "Unknown user"
+            if "actor" in activity and activity["actor"]:
+                actor_name = activity["actor"].get("login", "Unknown user")
             
-            if response.status_code == 200:
-                activities = response.json()
-                if not activities:
-                    return f"No activities found for repository {repo_full_name}"
-                
-                result = f"Repository activities for {repo_full_name}:\n\n"
-                
-                for activity in activities:
-                    # Extract common fields
-                    timestamp = activity.get("timestamp", "Unknown time")
-                    actor_name = "Unknown user"
-                    if "actor" in activity and activity["actor"]:
-                        actor_name = activity["actor"].get("login", "Unknown user")
-                    
-                    # Create a simple description of the activity
-                    result += f"- {actor_name} performed an activity at {timestamp}\n"
-                
-                return result
-            elif response.status_code == 404:
-                return f"Repository {repo_full_name} not found"
-            else:
-                logger.error(response.text)
-                return f"Error retrieving activities: {response.status_code} - {response.text}"
-        except NotAuthorizedError as e:
-            return e.message
-        except Exception as e:
-            logger.error(e)
-            return f"Error retrieving activities: {str(e)}"
+            # Create a simple description of the activity
+            result += f"- {actor_name} performed an activity at {timestamp}\n"
+        
+        return result
 
     def list_tools(self):
         return [self.star_repository, self.list_commits, self.list_branches,