Add base url as parameter

Author: MDUYN

finterion/configuration/constants.py

@@ -0,0 +1,31 @@
+def get_retrieve_order_url(base_url, order_id):
+    return f"{base_url}/orders/{order_id}"
+
+
+def get_list_orders_url(base_url):
+    return f"{base_url}/orders"
+
+
+def create_order_url(base_url):
+    return f"{base_url}/orders"
+
+
+def get_ping_url(base_url):
+    return f"{base_url}/status/ping"
+
+
+def get_algorithm_url(base_url):
+    return base_url
+
+
+def get_list_positions_url(base_url):
+    return f"{base_url}/positions"
+
+
+def get_retrieve_position_url(base_url, position_id):
+    return f"{base_url}/positions/{position_id}"
+
+
+def get_retrieve_portfolio_url(base_url):
+    return f"{base_url}/portfolio"
+

finterion/configuration/urls.py

@@ -3,18 +3,28 @@
 
 class Finterion:
 
-    def __init__(self, api_key):
+    def __init__(self, api_key, base_url="https://api.finterion.com/algs"):
         self.api_key = api_key
+        self.base_url = base_url
         self.ping()
         self.algorithm = self.get_algorithm_model()
 
     def ping(self):
-        return services.ping(self.api_key)
+        return services.ping(self.api_key, base_url=self.base_url)
 
     def get_algorithm_model(self):
-        return services.get_algorithm_model(self.api_key)
-
-    def get_orders(self, status=None, target_symbol=None, symbol=None, order_type=None, order_side=None):
+        return services.get_algorithm_model(
+            self.api_key, base_url=self.base_url
+        )
+
+    def get_orders(
+        self,
+        status=None,
+        target_symbol=None,
+        symbol=None,
+        order_type=None,
+        order_side=None
+    ):
         query_params = {"itemized": "true"}
 
         if status is not None:
@@ -32,21 +42,29 @@ def get_orders(self, status=None, target_symbol=None, symbol=None, order_type=No
         if order_side is not None:
             query_params["side"] = order_side
 
-        orders = services.get_orders(self.api_key, query_params)
+        orders = services.get_orders(
+            self.api_key, query_params, base_url=self.base_url
+        )
         return orders["items"]
 
     def get_order(self, order_id):
-        return services.get_order(self.api_key, order_id)
+        return services.get_order(
+            self.api_key, order_id, base_url=self.base_url
+        )
 
-    def create_order(self, target_symbol, order_side, order_type, amount, price):
+    def create_order(
+        self, target_symbol, order_side, order_type, amount, price
+    ):
         data = {
             "target_symbol": target_symbol,
             "side": order_side,
             "type": order_type,
             "amount": amount,
             "price": price
         }
-        return services.create_order(self.api_key, data)
+        return services.create_order(
+            self.api_key, data, base_url=self.base_url
+        )
 
     def create_limit_order(self, target_symbol, order_side, amount, price):
         data = {
@@ -56,7 +74,9 @@ def create_limit_order(self, target_symbol, order_side, amount, price):
             "amount": amount,
             "price": price
         }
-        return services.create_order(self.api_key, data)
+        return services.create_order(
+            self.api_key, data, base_url=self.base_url
+        )
 
     def create_market_order(self, target_symbol, order_side, amount):
 
@@ -71,19 +91,27 @@ def create_market_order(self, target_symbol, order_side, amount):
             "type": "MARKET",
             "amount": amount,
         }
-        return services.create_order(self.api_key, data)
+        return services.create_order(
+            self.api_key, data, base_url=self.base_url
+        )
 
     def get_position(self, position_id):
-        return services.get_position(self.api_key, position_id)
+        return services.get_position(
+            self.api_key, position_id, base_url=self.base_url
+        )
 
     def get_positions(self, symbol=None):
         query_params = {"itemized": "true"}
 
         if symbol is not None:
             query_params["symbol"] = symbol
 
-        positions = services.get_positions(self.api_key, query_params)
+        positions = services.get_positions(
+            self.api_key, query_params, base_url=self.base_url
+        )
         return positions["items"]
 
     def get_portfolio(self):
-        return services.get_portfolio(self.api_key)
+        return services.get_portfolio(
+            self.api_key, self.base_url
+        )

finterion/finterion.py

@@ -1,8 +1,12 @@
 import json
+import logging
 
 import requests
-import logging
-from finterion.configuration import constants
+
+from finterion.configuration.urls import get_retrieve_order_url, \
+    get_ping_url, get_algorithm_url, get_retrieve_portfolio_url, \
+    get_retrieve_position_url, get_list_positions_url, get_list_orders_url, \
+    create_order_url
 from finterion.exceptions import ClientException
 
 logger = logging.getLogger(__name__)
@@ -17,62 +21,71 @@ def handle_response(response):
     if response.status_code == 401:
         raise ClientException("Unauthorized, check your API key")
     elif response.status_code == 400:
-
         data = response.json()
+        logger.error(data)
 
         if "message" in data:
             raise ClientException(data["message"])
 
+        if "error" in data:
+            raise ClientException(data["error"])
+
         raise ClientException("Something went wrong")
     else:
         raise ClientException("Error connecting to finterion platform")
 
 
-def ping(api_key, url=constants.PING_ENDPOINT):
+def ping(api_key, base_url):
+    url = get_ping_url(base_url)
     response = requests.get(url, headers={"XApiKey": api_key})
     return handle_response(response)
 
 
-def get_algorithm_model(api_key, url=constants.ALGORITHM_ENDPOINT):
+def get_algorithm_model(api_key, base_url):
+    url = get_algorithm_url(base_url)
     response = requests.get(url, headers={"XApiKey": api_key})
     return handle_response(response)
 
 
-def get_orders(api_key, query_params, url=constants.LIST_ORDERS_ENDPOINT):
+def get_orders(api_key, query_params, base_url):
+    url = get_list_orders_url(base_url)
     response = requests.get(
         url, headers={"XApiKey": api_key}, params=query_params
     )
     return handle_response(response)
 
 
-def get_order(api_key, query_params, url=constants.RETRIEVE_ORDER_ENDPOINT):
+def get_order(api_key, query_params, base_url):
+    url = get_retrieve_order_url(base_url, query_params["order_id"])
     response = requests.get(
         url, headers={"XApiKey": api_key}, params=query_params
     )
     return handle_response(response)
 
 
-def create_order(api_key, data, url=constants.CREATE_ORDER_ENDPOINT):
+def create_order(api_key, data, base_url):
+    url = create_order_url(base_url)
     response = requests.post(
         url, headers={"XApiKey": api_key}, json=json.dumps(data)
     )
     return handle_response(response)
 
 
-def get_positions(api_key, query_params, url=constants.LIST_POSITIONS):
+def get_positions(api_key, query_params, base_url):
+    url = get_list_positions_url(base_url)
     response = requests.get(
         url, headers={"XApiKey": api_key}, params=query_params
     )
     return handle_response(response)
 
 
-def get_position(api_key, position_id, url=constants.RETRIEVE_POSITION):
-    response = requests.get(
-        url.format(position_id=position_id), headers={"XApiKey": api_key}
-    )
+def get_position(api_key, position_id, base_url):
+    url = get_retrieve_position_url(base_url, position_id)
+    response = requests.get(url, headers={"XApiKey": api_key})
     return handle_response(response)
 
 
-def get_portfolio(api_key, url=constants.PORTFOLIO_ENDPOINT):
+def get_portfolio(api_key, base_url):
+    url = get_retrieve_portfolio_url(base_url)
     response = requests.get(url, headers={"XApiKey": api_key})
     return handle_response(response)

finterion/services.py

@@ -1,4 +1,4 @@
-VERSION = (0, 4, 0, 'alpha', 0)
+VERSION = (0, 5, 0, 'alpha', 0)
 
 
 def get_version(version=None):