agentr 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

agentr/__init__.py

@@ -1,2 +1,2 @@
-def main():
+def main():
     print("hello")

agentr/application.py

@@ -1,57 +1,57 @@
-from abc import ABC, abstractmethod
-from agentr.integration import Integration
-import httpx
-
-class Application(ABC):
-    """
-    Application is collection of tools that can be used by an agent.
-    """
-    def __init__(self, name: str, **kwargs):
-        self.name = name
-
-    @abstractmethod
-    def list_tools(self):
-        pass
-
-
-class APIApplication(Application):
-    """
-    APIApplication is an application that uses an API to interact with the world.
-    """
-    def __init__(self, name: str, integration: Integration = None, **kwargs):
-        super().__init__(name, **kwargs)
-        self.integration = integration
-
-    def _get_headers(self):
-        return {}
-    
-    def _get(self, url, params=None):
-        headers = self._get_headers()
-        response = httpx.get(url, headers=headers, params=params)
-        response.raise_for_status()
-        return response
-    
-    def _post(self, url, data):
-        headers = self._get_headers()
-        response = httpx.post(url, headers=headers, json=data)
-        response.raise_for_status()
-        return response
-
-    def _put(self, url, data):
-        headers = self._get_headers()
-        response = httpx.put(url, headers=headers, json=data)
-        response.raise_for_status()
-        return response
-
-    def _delete(self, url):
-        headers = self._get_headers()
-        response = httpx.delete(url, headers=headers)
-        response.raise_for_status()
-        return response
-
-    def validate(self):
-        pass
-    
-    @abstractmethod
-    def list_tools(self):
+from abc import ABC, abstractmethod
+from agentr.integration import Integration
+import httpx
+
+class Application(ABC):
+    """
+    Application is collection of tools that can be used by an agent.
+    """
+    def __init__(self, name: str, **kwargs):
+        self.name = name
+
+    @abstractmethod
+    def list_tools(self):
+        pass
+
+
+class APIApplication(Application):
+    """
+    APIApplication is an application that uses an API to interact with the world.
+    """
+    def __init__(self, name: str, integration: Integration = None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.integration = integration
+
+    def _get_headers(self):
+        return {}
+    
+    def _get(self, url, params=None):
+        headers = self._get_headers()
+        response = httpx.get(url, headers=headers, params=params)
+        response.raise_for_status()
+        return response
+    
+    def _post(self, url, data):
+        headers = self._get_headers()
+        response = httpx.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        return response
+
+    def _put(self, url, data):
+        headers = self._get_headers()
+        response = httpx.put(url, headers=headers, json=data)
+        response.raise_for_status()
+        return response
+
+    def _delete(self, url):
+        headers = self._get_headers()
+        response = httpx.delete(url, headers=headers)
+        response.raise_for_status()
+        return response
+
+    def validate(self):
+        pass
+    
+    @abstractmethod
+    def list_tools(self):
         pass

agentr/applications/github/app.py

@@ -1,52 +1,56 @@
-from agentr.integration import Integration
-from agentr.application import APIApplication
-from loguru import logger
-
-
-class GithubApp(APIApplication):
-    def __init__(self, integration: Integration) -> None:
-        super().__init__(name="github", integration=integration)
-
-    def _get_headers(self):
-        if not self.integration:
-            raise ValueError("Integration not configured")
-        credentials = self.integration.get_credentials()
-        if not credentials:
-            logger.warning("No credentials found")
-            return self.integration.authorize()
-        if "headers" in credentials:
-            return credentials["headers"]
-        return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-            "Accept": "application/vnd.github.v3+json"
-        }
-    
-
-    def star_repository(self, repo_full_name: str) -> str:
-        """Star a GitHub repository
-        
-            Args:
-                repo_full_name: The full name of the repository (e.g. 'owner/repo')
-                
-            Returns:
-            
-                A confirmation message
-        """
-        try:
-            url = f"https://api.github.com/user/starred/{repo_full_name}"
-            response = self._put(url, data={})
-            
-            if response.status_code == 204:
-                return f"Successfully starred repository {repo_full_name}"
-            elif response.status_code == 404:
-                return f"Repository {repo_full_name} not found"
-            else:
-                logger.error(response.text)
-                return f"Error starring repository: {response.text}"
-        except Exception as e:
-            logger.error(e)
-            return f"Error starring repository: {e}"
-
-    
-    def list_tools(self):
+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:
+        super().__init__(name="github", integration=integration)
+
+    def _get_headers(self):
+        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 {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/vnd.github.v3+json"
+        }
+    
+
+    def star_repository(self, repo_full_name: str) -> str:
+        """Star a GitHub repository
+        
+            Args:
+                repo_full_name: The full name of the repository (e.g. 'owner/repo')
+                
+            Returns:
+            
+                A confirmation message
+        """
+        try:
+            url = f"https://api.github.com/user/starred/{repo_full_name}"
+            response = self._put(url, data={})
+            
+            if response.status_code == 204:
+                return f"Successfully starred repository {repo_full_name}"
+            elif response.status_code == 404:
+                return f"Repository {repo_full_name} not found"
+            else:
+                logger.error(response.text)
+                return f"Error starring repository: {response.text}"
+        except NotAuthorizedError as e:
+            return e.message
+        except Exception as e:
+            logger.error(e)
+            raise e
+       
+
+    
+    def list_tools(self):
         return [self.star_repository]

agentr/applications/google_calendar/app.py

@@ -1,74 +1,74 @@
-from agentr.application import APIApplication
-from agentr.integration import Integration
-from loguru import logger
-from datetime import datetime, timedelta
-
-class GoogleCalendarApp(APIApplication):
-    def __init__(self, integration: Integration) -> None:
-        super().__init__(name="google-calendar", integration=integration)
-
-    def _get_headers(self):
-        credentials = self.integration.get_credentials()
-        if "headers" in credentials:
-            return credentials["headers"]
-        return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-            "Accept": "application/json"
-        }
-    
-    
-    def get_today_events(self) -> str:
-        """Get events from your Google Calendar for today
-        
-        Returns:
-            A formatted list of today's events or an error message
-        """
-        if not self.validate():
-            logger.warning("Connection not configured correctly")
-            return self.authorize()
-        
-        try:
-            # Get today's date in ISO format
-            today = datetime.now().date()
-            tomorrow = today + timedelta(days=1)
-            
-            # Format dates for API
-            time_min = f"{today.isoformat()}T00:00:00Z"
-            time_max = f"{tomorrow.isoformat()}T00:00:00Z"
-            
-            url = "https://www.googleapis.com/calendar/v3/calendars/primary/events"
-            params = {
-                "timeMin": time_min,
-                "timeMax": time_max,
-                "singleEvents": "true",
-                "orderBy": "startTime"
-            }
-            
-            response = self._get(url, params=params)
-            
-            if response.status_code == 200:
-                events = response.json().get("items", [])
-                if not events:
-                    return "No events scheduled for today."
-                
-                result = "Today's events:\n\n"
-                for event in events:
-                    start = event.get("start", {})
-                    start_time = start.get("dateTime", start.get("date", "All day"))
-                    if "T" in start_time:  # Format datetime
-                        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
-                        start_time = start_dt.strftime("%I:%M %p")
-                    
-                    summary = event.get("summary", "Untitled event")
-                    result += f"- {start_time}: {summary}\n"
-                
-                return result
-            else:
-                logger.error(response.text)
-                return f"Error retrieving calendar events: {response.text}"
-        except Exception as e:
-            logger.error(e)
-            return f"Error retrieving calendar events: {e}"
-    
-    def list_tools(self):
+from agentr.application import APIApplication
+from agentr.integration import Integration
+from loguru import logger
+from datetime import datetime, timedelta
+
+class GoogleCalendarApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="google-calendar", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/json"
+        }
+    
+    
+    def get_today_events(self) -> str:
+        """Get events from your Google Calendar for today
+        
+        Returns:
+            A formatted list of today's events or an error message
+        """
+        if not self.validate():
+            logger.warning("Connection not configured correctly")
+            return self.authorize()
+        
+        try:
+            # Get today's date in ISO format
+            today = datetime.now().date()
+            tomorrow = today + timedelta(days=1)
+            
+            # Format dates for API
+            time_min = f"{today.isoformat()}T00:00:00Z"
+            time_max = f"{tomorrow.isoformat()}T00:00:00Z"
+            
+            url = "https://www.googleapis.com/calendar/v3/calendars/primary/events"
+            params = {
+                "timeMin": time_min,
+                "timeMax": time_max,
+                "singleEvents": "true",
+                "orderBy": "startTime"
+            }
+            
+            response = self._get(url, params=params)
+            
+            if response.status_code == 200:
+                events = response.json().get("items", [])
+                if not events:
+                    return "No events scheduled for today."
+                
+                result = "Today's events:\n\n"
+                for event in events:
+                    start = event.get("start", {})
+                    start_time = start.get("dateTime", start.get("date", "All day"))
+                    if "T" in start_time:  # Format datetime
+                        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                        start_time = start_dt.strftime("%I:%M %p")
+                    
+                    summary = event.get("summary", "Untitled event")
+                    result += f"- {start_time}: {summary}\n"
+                
+                return result
+            else:
+                logger.error(response.text)
+                return f"Error retrieving calendar events: {response.text}"
+        except Exception as e:
+            logger.error(e)
+            return f"Error retrieving calendar events: {e}"
+    
+    def list_tools(self):
         return [self.get_today_events]

agentr/applications/google_mail/app.py

@@ -1,68 +1,68 @@
-from agentr.application import APIApplication
-from agentr.integration import Integration
-from loguru import logger
-import base64
-from email.message import EmailMessage
-
-class GmailApp(APIApplication):
-    def __init__(self, integration: Integration) -> None:
-        super().__init__(name="gmail", integration=integration)
-
-    def _get_headers(self):
-        credentials = self.integration.get_credentials()
-        if "headers" in credentials:
-            return credentials["headers"]
-        return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-            'Content-Type': 'application/json'
-        }
-
-    def send_email(self, to: str, subject: str, body: str) -> str:
-        """Send an email
-        
-        Args:
-            to: The email address of the recipient
-            subject: The subject of the email
-            body: The body of the email
-            
-        Returns:
-        
-            A confirmation message
-        """
-        if not self.validate():
-            logger.warning("Connection not configured correctly")
-            return self.authorize()
-        try:
-            url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
-            
-            # Create email in base64 encoded format
-            email_message = {
-                "raw": self._create_message(to, subject, body)
-            }
-            logger.info(email_message)
-            
-            # Use json parameter instead of data to properly format JSON
-            response = self._post(url, email_message)
-            
-            if response.status_code == 200:
-                return f"Successfully sent email to {to}"
-            else:
-                logger.error(response.text)
-                return f"Error sending email: {response.text}"
-        except Exception as e:
-            logger.error(e)
-            return f"Error sending email: {e}"
-            
-    def _create_message(self, to, subject, body):
-        message = EmailMessage()
-        message['to'] = to
-        message['from'] = "manojbajaj95@gmail.com"
-        message['subject'] = subject
-        message.set_content(body)
-        
-        # Encode as base64 string
-        raw = base64.urlsafe_b64encode(message.as_bytes()).decode()
-        return raw
-    
-    def list_tools(self):
+from agentr.application import APIApplication
+from agentr.integration import Integration
+from loguru import logger
+import base64
+from email.message import EmailMessage
+
+class GmailApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="gmail", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            'Content-Type': 'application/json'
+        }
+
+    def send_email(self, to: str, subject: str, body: str) -> str:
+        """Send an email
+        
+        Args:
+            to: The email address of the recipient
+            subject: The subject of the email
+            body: The body of the email
+            
+        Returns:
+        
+            A confirmation message
+        """
+        if not self.validate():
+            logger.warning("Connection not configured correctly")
+            return self.authorize()
+        try:
+            url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
+            
+            # Create email in base64 encoded format
+            email_message = {
+                "raw": self._create_message(to, subject, body)
+            }
+            logger.info(email_message)
+            
+            # Use json parameter instead of data to properly format JSON
+            response = self._post(url, email_message)
+            
+            if response.status_code == 200:
+                return f"Successfully sent email to {to}"
+            else:
+                logger.error(response.text)
+                return f"Error sending email: {response.text}"
+        except Exception as e:
+            logger.error(e)
+            return f"Error sending email: {e}"
+            
+    def _create_message(self, to, subject, body):
+        message = EmailMessage()
+        message['to'] = to
+        message['from'] = "manojbajaj95@gmail.com"
+        message['subject'] = subject
+        message.set_content(body)
+        
+        # Encode as base64 string
+        raw = base64.urlsafe_b64encode(message.as_bytes()).decode()
+        return raw
+    
+    def list_tools(self):
         return [self.send_email]

agentr/applications/reddit/app.py

@@ -1,29 +1,29 @@
-from agentr.application import APIApplication
-from agentr.integration import Integration
-
-class RedditApp(APIApplication):
-    def __init__(self, integration: Integration) -> None:
-        super().__init__(name="reddit", integration=integration)
-
-    def _get_headers(self):
-        credentials = self.integration.get_credentials()
-        if "headers" in credentials:
-            return credentials["headers"]
-        return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-        }
-
-    def get_subreddit_posts(self, subreddit: str) -> str:
-        """Get the latest posts from a subreddit
-        
-        Args:
-            subreddit: The subreddit to get posts from
-            
-        Returns:
-            A list of posts from the subreddit
-        """
-        
-
-    def list_tools(self):
-        return []
-    
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class RedditApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="reddit", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+        }
+
+    def get_subreddit_posts(self, subreddit: str) -> str:
+        """Get the latest posts from a subreddit
+        
+        Args:
+            subreddit: The subreddit to get posts from
+            
+        Returns:
+            A list of posts from the subreddit
+        """
+        
+
+    def list_tools(self):
+        return []
+    

agentr/applications/resend/app.py

@@ -1,43 +1,43 @@
-from agentr.application import APIApplication
-from agentr.integration import Integration
-
-class ResendApp(APIApplication):
-    def __init__(self, integration: Integration) -> None:
-        super().__init__(name="resend", integration=integration)
-
-    def _get_headers(self):
-        credentials = self.integration.get_credentials()
-        if not credentials:
-            raise ValueError("No credentials found")
-        return {
-            "Authorization": f"Bearer {credentials['api_key']}",
-        }
-
-    def send_email(self, to: str, subject: str, content: str) -> str:
-        """Send an email using the Resend API
-
-        Args:
-            to: The email address to send the email to
-            subject: The subject of the email
-            content: The content of the email
-            
-        Returns:
-            A message indicating that the email was sent successfully
-        """
-        credentials = self.integration.get_credentials()
-        if not credentials:
-            raise ValueError("No credentials found")
-        from_email = credentials.get("from_email", "Manoj <manoj@agentr.dev>")
-        url = "https://api.resend.com/emails"
-        body = {
-            "from": from_email,
-            "to": [to],
-            "subject": subject,
-            "text": content
-        }
-        self._post(url, body)
-        return "Sent Successfully"
-
-    def list_tools(self):
-        return [self.send_email]
-
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class ResendApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="resend", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found")
+        return {
+            "Authorization": f"Bearer {credentials['api_key']}",
+        }
+
+    def send_email(self, to: str, subject: str, content: str) -> str:
+        """Send an email using the Resend API
+
+        Args:
+            to: The email address to send the email to
+            subject: The subject of the email
+            content: The content of the email
+            
+        Returns:
+            A message indicating that the email was sent successfully
+        """
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found")
+        from_email = credentials.get("from_email", "Manoj <manoj@agentr.dev>")
+        url = "https://api.resend.com/emails"
+        body = {
+            "from": from_email,
+            "to": [to],
+            "subject": subject,
+            "text": content
+        }
+        self._post(url, body)
+        return "Sent Successfully"
+
+    def list_tools(self):
+        return [self.send_email]
+