pyfsr 0.1.4__py3-none-any.whl

pyfsr/__init__.py

@@ -0,0 +1,5 @@
+from .client import FortiSOAR
+from .exceptions import FortiSOARException, AuthenticationError
+
+__all__ = ['FortiSOAR', 'FortiSOARException', 'AuthenticationError']
+__version__ = "0.1.0"

pyfsr/api/alerts.py

@@ -0,0 +1,31 @@
+from typing import Dict
+
+from .base import BaseAPI
+
+
+class AlertsAPI(BaseAPI):
+    """Alerts API endpoints"""
+
+    def __init__(self, client):
+        super().__init__(client)
+        self.module = 'alerts'
+
+    def create(self, **data: Dict) -> Dict:
+        """Create a new alert"""
+        return self._make_request('POST', f'/{self.module}', json=data)
+
+    def get(self, alert_id: str) -> Dict:
+        """Get alert by ID"""
+        return self._make_request('GET', f'/{self.module}/{alert_id}')
+
+    def get_all(self) -> Dict:
+        """Get All alerts"""
+        return self._make_request('GET', f'/{self.module}')
+
+    def update(self, alert_id: str, data: Dict) -> Dict:
+        """Update an alert"""
+        return self._make_request('PUT', f'/{self.module}/{alert_id}', json=data)
+
+    def delete(self, alert_id: str) -> None:
+        """Delete an alert"""
+        return self._make_request('DELETE', f'/{self.module}/{alert_id}')

pyfsr/api/base.py

@@ -0,0 +1,17 @@
+from ..exceptions import APIError
+
+
+class BaseAPI:
+    """Base API class for all module-specific APIs"""
+
+    def __init__(self, client):
+        self.client = client
+
+    def _make_request(self, method: str, endpoint: str, **kwargs):
+        """Make API request with error handling"""
+        try:
+            response = self.client.request(method, endpoint, **kwargs)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            raise APIError(f"API request failed: {str(e)}")

pyfsr/auth/api_key.py

@@ -0,0 +1,12 @@
+from .base import BaseAuth
+
+
+class APIKeyAuth(BaseAuth):
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    def get_auth_headers(self) -> dict:
+        return {
+            'Authorization': f'API-KEY {self.api_key}',
+            'Content-Type': 'application/json'
+        }

pyfsr/auth/base.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+
+class BaseAuth(ABC):
+    """Base authentication class"""
+
+    @abstractmethod
+    def get_auth_headers(self) -> dict:
+        """Return authentication headers"""
+        pass

pyfsr/auth/user_pass.py

@@ -0,0 +1,31 @@
+import requests
+
+from .base import BaseAuth
+
+
+class UserPasswordAuth(BaseAuth):
+    def __init__(self, username: str, password: str, base_url: str, verify_ssl: bool = True,
+                 ):
+        self.username = username
+        self.password = password
+        self.base_url = base_url
+        self.verify_ssl = verify_ssl
+        self.token = self._authenticate()
+
+    def _authenticate(self) -> str:
+        auth_url = f"{self.base_url}/auth/authenticate"
+        payload = {
+            "credentials": {
+                "loginid": self.username,
+                "password": self.password
+            }
+        }
+        response = requests.post(auth_url, json=payload, verify=self.verify_ssl)
+        response.raise_for_status()
+        return response.json()['token']
+
+    def get_auth_headers(self) -> dict:
+        return {
+            'Authorization': f'Bearer {self.token}',
+            'Content-Type': 'application/json'
+        }

pyfsr/client.py

@@ -0,0 +1,147 @@
+from typing import Union, Optional, Dict, Any
+from urllib.parse import urljoin
+
+import requests
+
+from .api.alerts import AlertsAPI
+from .auth.api_key import APIKeyAuth
+from .auth.user_pass import UserPasswordAuth
+from .constants import API_PATH
+
+
+class FortiSOAR:
+    """
+   Main client class for FortiSOAR API
+
+   Attributes:
+       base_url (str): The base URL for the FortiSOAR API.
+       session (requests.Session): The session object for making HTTP requests.
+       verify_ssl (bool): Whether to verify SSL certificates.
+       auth (Union[APIKeyAuth, UserPasswordAuth]): The authentication method.
+       alerts (AlertsAPI): The Alerts API interface.
+   """
+
+    def __init__(
+            self,
+            base_url: str,
+            auth: Union[str, tuple],
+            verify_ssl: bool = True,
+            supress_insecure_warnings: bool = False
+    ):
+
+        """
+               Initialize the FortiSOAR client.
+
+               Args:
+                   base_url (str): The base URL for the FortiSOAR API.
+                   auth (Union[str, tuple]): The authentication method, either an API key (str) or a tuple of (username, password).
+                   verify_ssl (bool, optional): Whether to verify SSL certificates. Defaults to True.
+                   supress_insecure_warnings (bool, optional): Whether to suppress insecure request warnings. Defaults to False.
+
+               Raises:
+                   ValueError: If the provided authentication method is invalid.
+               """
+        self.base_url = base_url.rstrip('/')
+        self.session = requests.Session()
+        self.session.verify = verify_ssl
+        self.verify_ssl = verify_ssl
+        if supress_insecure_warnings:
+            requests.packages.urllib3.disable_warnings(requests.packages.urllib3.exceptions.InsecureRequestWarning)
+
+        # Setup authentication
+        if isinstance(auth, str):
+            self.auth = APIKeyAuth(auth)
+        elif isinstance(auth, tuple) and len(auth) == 2:
+            username, password = auth
+            self.auth = UserPasswordAuth(username, password, self.base_url, self.verify_ssl)
+        else:
+            raise ValueError("Invalid authentication provided")
+
+        # Apply authentication headers
+        self.session.headers.update(self.auth.get_auth_headers())
+
+        # Initialize API interfaces
+        self.alerts = AlertsAPI(self)
+
+    def request(
+            self,
+            method: str,
+            endpoint: str,
+            params: Optional[Dict] = None,
+            data: Optional[Dict] = None,
+            **kwargs
+    ) -> requests.Response:
+        """
+        Make HTTP request to FortiSOAR API
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE)
+            endpoint: API endpoint path
+            params: Query parameters
+            data: Request body data
+            **kwargs: Additional arguments to pass to requests
+
+        Returns:
+            Response from the API
+
+        Raises:
+            requests.exceptions.RequestException: If the request fails
+        """
+        # Ensure endpoint starts with slash for proper URL joining
+        if not endpoint.startswith('/'):
+            endpoint = f'/{endpoint}'
+
+        # For API v3 endpoints, prepend the API path if not already present
+        if not endpoint.startswith(API_PATH) and not endpoint.startswith('/auth'):
+            endpoint = f"{API_PATH}{endpoint}"
+
+        url = urljoin(self.base_url, endpoint)
+
+        try:
+            response = self.session.request(
+                method=method.upper(),
+                url=url,
+                params=params,
+                json=data,
+                **kwargs
+            )
+            response.raise_for_status()
+            return response
+
+        except requests.exceptions.RequestException as e:
+            error_msg = f"API request failed: {str(e)}"
+            if hasattr(e.response, 'text'):
+                error_msg += f"\nResponse: {e.response.text}"
+            raise requests.exceptions.RequestException(error_msg)
+
+    def get(self, endpoint: str, params: Optional[Dict] = None, **kwargs) -> Dict[str, Any]:
+        """Perform GET request and return JSON response"""
+        response = self.request('GET', endpoint, params=params, **kwargs)
+        return response.json()
+
+    def post(self, endpoint: str, data: Dict, params: Optional[Dict] = None, **kwargs) -> Dict[str, Any]:
+        """Perform POST request and return JSON response"""
+        response = self.request('POST', endpoint, params=params, data=data, **kwargs)
+        return response.json()
+
+    def put(self, endpoint: str, data: Dict, params: Optional[Dict] = None, **kwargs) -> Dict[str, Any]:
+        """Perform PUT request and return JSON response"""
+        response = self.request('PUT', endpoint, params=params, data=data, **kwargs)
+        return response.json()
+
+    def delete(self, endpoint: str, params: Optional[Dict] = None, **kwargs) -> None:
+        """Perform DELETE request"""
+        self.request('DELETE', endpoint, params=params, **kwargs)
+
+    def query(self, module: str, query_data: Dict) -> Dict[str, Any]:
+        """
+        Execute a query against a module
+
+        Args:
+            module: Name of the module to query
+            query_data: Query parameters and filters
+
+        Returns:
+            Query results
+        """
+        return self.post(f'/query/{module}', data=query_data)

pyfsr/constants.py

@@ -0,0 +1,3 @@
+DEFAULT_API_VERSION = "3"
+API_PATH = f"/api/{DEFAULT_API_VERSION}"
+QUERY_PATH = "/api/query"

pyfsr/exceptions.py

@@ -0,0 +1,11 @@
+class FortiSOARException(Exception):
+    """Base exception for FortiSOAR client"""
+    pass
+
+class AuthenticationError(FortiSOARException):
+    """Authentication related errors"""
+    pass
+
+class APIError(FortiSOARException):
+    """API related errors"""
+    pass

pyfsr-0.1.4.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: pyfsr
+Version: 0.1.4
+Summary: Python implementation of the FortiSOAR REST API
+Project-URL: Homepage, https://github.com/ftnt-dspille/pyFSR
+Project-URL: Bug Tracker, https://github.com/ftnt-dspille/pyFSR/issues
+Project-URL: Documentation, https://github.com/ftnt-dspille/pyFSR#readme
+Project-URL: Source Code, https://github.com/ftnt-dspille/pyFSR
+Author-email: Dylan Spille <dspille@fortinet.com>
+License: MIT
+License-File: LICENSE
+Keywords: api,fortinet,fortisoar,rest
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pyfsr
+
+Goal of the library is be a Python Client for the FortiSOAR Rest API. 
+
+## Installation
+
+```bash
+pip install pyfsr
+```
+
+This library is a work in progress and is not yet ready for production use.
+

pyfsr-0.1.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+pyfsr/__init__.py,sha256=4D6Vkba5JllMVrnEMaRXSUcI8MC0BFBImdJquoNiO14,186
+pyfsr/client.py,sha256=j1SD3a3OhB4-h7lAbO2PTH8LSzuATkmYLonGdMnYamw,5400
+pyfsr/constants.py,sha256=AXz7LqxM2ctGT4H7xRqQw4mMmvjiYB2_-BDltdzhtIo,92
+pyfsr/exceptions.py,sha256=Kb8t7FLrUMa6Fz9tM5QBgl-ZlPq-360S8Kuaj8lRBFU,264
+pyfsr/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyfsr/api/alerts.py,sha256=9ORh66j3LC1DG-EE0mjfe7BaLEp9tfUtj8QMrKuJlWc,942
+pyfsr/api/base.py,sha256=gBnGeEMFJRdi1Ph9IhOzHL9hKeXHBNVVjfz25p4qlzc,536
+pyfsr/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyfsr/auth/api_key.py,sha256=pGDbqj_FSCdKYpKRWlCEStbUAQtl5FwcwWSlX0R_rEg,297
+pyfsr/auth/base.py,sha256=JSBOZc_v-WbTgmmm3k5oRwCHO2XUK40Pz12-6mn-jO8,212
+pyfsr/auth/user_pass.py,sha256=I94a2S601swfuXd_B1pZ3BYIQNZOPVKcFN3K08JiQ80,946
+pyfsr-0.1.4.dist-info/METADATA,sha256=He66j1zXW-sAl5pN1XpNyxNjVlIw1ejcJjz_Zqzrr2g,1305
+pyfsr-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyfsr-0.1.4.dist-info/licenses/LICENSE,sha256=jnmypcXoJPIsS0b_Al7_KKxfzLszI4hXqvP9Zy0Pyt8,1069
+pyfsr-0.1.4.dist-info/RECORD,,

pyfsr-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyfsr-0.1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Dylan Spille
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.