PyZipline/pyzipline/rest_adapter.py

138 lines
7.5 KiB
Python
Raw Normal View History

2023-12-20 23:50:03 -05:00
"""This module contains the RestAdapter class, which is used to make requests to the Zipline server."""""
2023-12-19 05:36:18 -05:00
import logging
from json import JSONDecodeError
2023-12-19 02:16:31 -05:00
import requests
from urllib3 import disable_warnings
2023-12-20 20:48:18 -05:00
from pyzipline.exceptions import HTTPFailure, PyZiplineError
2024-03-28 11:28:24 -04:00
from pyzipline.models import Result, ZiplineApiConfig
2023-12-19 02:16:31 -05:00
2023-12-19 02:16:31 -05:00
class RestAdapter:
"""Constructor for RestAdapter
Args:
2024-03-28 11:28:24 -04:00
config (ZiplineApiConfig): Configuration object for the ZiplineApi class
Raises:
ValueError: Raised when the keyword arguments passed to the class constructor conflict.
"""
2024-03-28 11:28:24 -04:00
def __init__(self, config = ZiplineApiConfig):
self._url = f"http{'s' if config.ssl else ''}://{config.hostname}/api/"
self._token = config.token
self._ssl = config.ssl
self._enforced_signing = config.enforced_signing
self._logger = config.logger or logging.getLogger(__name__)
if config.ssl is False and config.enforced_signing is True:
raise ValueError("Cannot enforce signing without SSL")
2023-12-19 05:36:18 -05:00
2024-03-28 11:28:24 -04:00
if not config.ssl and not config.enforced_signing:
2023-12-19 02:16:31 -05:00
disable_warnings()
2024-03-28 11:28:24 -04:00
def _do(self, http_method: str, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments
"""Internal method to make a request to the Zipline server. You shouldn't use this directly.
Args:
2023-12-22 13:48:21 -05:00
http_method (str): The [HTTP method](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) to use
endpoint (str): The endpoint to make the request to.
headers (dict): Python dictionary of headers to send with the request.
2023-12-22 13:48:21 -05:00
params (dict): Python dictionary of query parameters to send with the request.
json (dict): Python dictionary of JSON-serializable data to send with the request.
files (dict): Python dictionary of files to send with the request.
timeout (float): Number of seconds to wait for the request to complete.
Returns:
Result: A Result object containing the status code, message, and data from the request.
Raises:
HTTPError: Raised when an HTTP request fails.
PyZiplineError: Raised when an error occurs in the PyZipline library.
"""
2023-12-19 05:36:18 -05:00
full_url = self._url + endpoint
if not headers:
headers = {}
headers.update({'Authorization': self._token})
2023-12-19 05:36:18 -05:00
2023-12-20 20:48:45 -05:00
try: # Perform an HTTP request, catching and re-raising any exceptions
2023-12-19 05:36:18 -05:00
# will eventually refactor this to use asyncio/aiohttp instead for async operation
2023-12-22 13:48:21 -05:00
response = requests.request(method=http_method, url=full_url, verify=self._enforced_signing, params=params, headers=headers, json=json, files=files, timeout=timeout)
2023-12-19 05:36:18 -05:00
except requests.exceptions.RequestException as e:
2023-12-20 23:50:30 -05:00
self._logger.error(msg=str(e))
2023-12-19 05:36:18 -05:00
raise HTTPFailure("Could not connect to Zipline server") from e
try: # Deserialize JSON output to Python object, or return failed Result on exception
data_out = response.json()
except (ValueError, JSONDecodeError) as e:
if response.headers.get('Content-Type') == 'application/octet-stream':
# If the response contains a valid file, return success Result with file content
return Result(success=True, status_code=response.status_code, message=response.reason, data=response.content)
2023-12-22 21:05:17 -05:00
raise PyZiplineError("Could not decode response from Zipline server") from e
2023-12-19 05:36:18 -05:00
# If status_code in 200-299 range, return success Result with data, otherwise return failed Result with message
2023-12-19 05:36:18 -05:00
is_success = 299 >= response.status_code >= 200
2023-12-20 20:48:45 -05:00
if is_success:
return Result(success=is_success, status_code=response.status_code, message=response.reason, data=data_out)
2023-12-20 23:50:30 -05:00
return Result(success=is_success, status_code=response.status_code, message=data_out['error'], data=data_out)
2023-12-19 05:36:18 -05:00
2024-03-28 11:28:24 -04:00
def delete(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments
2023-12-22 13:48:21 -05:00
"""Make a DELETE request to the Zipline server. You should almost never have to use this directly.
Args:
endpoint (str): The endpoint to make the request to.
params (dict): Python dictionary of query parameters to send with the request.
json (dict): Python dictionary of JSON-serializable data to send with the request.
timeout (float): Number of seconds to wait for the request to complete.
Returns:
Result: A Result object containing the status code, message, and data from the request.
"""
return self._do(http_method='DELETE', endpoint=endpoint, headers=headers, params=params, json=json, timeout=timeout)
2023-12-22 13:48:21 -05:00
def get(self, endpoint: str, headers: dict = None, params: dict = None, timeout: float = 60) -> Result:
"""Make a GET request to the Zipline server. You should almost never have to use this directly.
Args:
endpoint (str): The endpoint to make the request to.
2023-12-22 13:48:21 -05:00
params (dict): Python dictionary of query parameters to send with the request.
timeout (float): Number of seconds to wait for the request to complete.
Returns:
Result: A Result object containing the status code, message, and data from the request.
"""
return self._do(http_method='GET', endpoint=endpoint, headers=headers, params=params, timeout=timeout)
2023-12-19 05:36:18 -05:00
2024-03-28 11:28:24 -04:00
def patch(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments
2023-12-22 13:48:21 -05:00
"""Make a PATCH request to the Zipline server. You should almost never have to use this directly.
Args:
endpoint (str): The endpoint to make the request to.
2023-12-22 13:48:21 -05:00
params (dict): Python dictionary of query parameters to send with the request.
json (dict): Python dictionary of JSON-serializable data to send with the request.
files (dict): Python dictionary of files to send with the request.
timeout (float): Number of seconds to wait for the request to complete.
Returns:
Result: A Result object containing the status code, message, and data from the request.
"""
return self._do(http_method='PATCH', endpoint=endpoint, headers=headers, params=params, json=json, files=files, timeout=timeout)
2023-12-19 05:36:18 -05:00
2024-03-28 11:28:24 -04:00
def post(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments
2023-12-22 13:48:21 -05:00
"""Make a POST request to the Zipline server. You should almost never have to use this directly.
Args:
endpoint (str): The endpoint to make the request to.
headers (dict): Python dictionary of headers to send with the request.
2023-12-22 13:48:21 -05:00
params (dict): Python dictionary of query parameters to send with the request.
json (dict): Python dictionary of JSON-serializable data to send with the request.
files (dict): Python dictionary of files to send with the request.
timeout (float): Number of seconds to wait for the request to complete.
Returns:
Result: A Result object containing the status code, message, and data from the request.
"""
return self._do(http_method='POST', endpoint=endpoint, headers=headers, params=params, json=json, files=files, timeout=timeout)