Convert API responses with Glom

core/exchanges/__init__.py

@@ -1,13 +1,16 @@
+from glom import glom
 from pydantic import ValidationError
 
+from core.lib import schemas
 from core.util import logs
 
 
 class BaseExchange(object):
     def __init__(self, account):
         name = self.__class__.__name__
+        self.name = name.replace("Exchange", "").lower()
         self.account = account
-        self.log = logs.get_logger(name)
+        self.log = logs.get_logger(self.name)
         self.client = None
 
         self.set_schema()
@@ -19,6 +22,26 @@ class BaseExchange(object):
     def connect(self):
         raise NotImplementedError
 
+    def convert_spec(self, response, msg_type):
+        # Does the schemas library have a library for this exchange name?
+        if hasattr(schemas, f"{self.name}_s"):
+            schema_instance = getattr(schemas, f"{self.name}_s")
+        else:
+            raise Exception(f"No schema for {self.name} in schema mapping")
+        # Does the message type have a conversion spec for this message type?
+        if hasattr(schema_instance, f"{msg_type}_schema"):
+            schema = getattr(schema_instance, f"{msg_type}_schema")
+        else:
+            # Let us know so we can implement it, but don't do anything with it
+            self.log.error(f"No schema for message: {msg_type} - {response}")
+            # raise Exception(f"No schema for {msg_type} in schema mapping")
+            return response
+
+        # Use glom to convert the response to the schema
+        converted = glom(response, schema)
+        print(f"[{self.name}] Converted of {msg_type}: {converted}")
+        return converted
+
     def call(self, method, *args, **kwargs) -> (bool, dict):
 
         if hasattr(self.client, method):
@@ -29,8 +52,13 @@ class BaseExchange(object):
                 if method not in self.schema:
                     self.log.error(f"Method cannot be validated: {method}")
                     self.log.debug(f"Response: {response}")
-                    return (False, f"Method cannot be validated: {method}")
-                return (True, self.schema[method](**response).dict())
+                    # return (False, f"Method cannot be validated: {method}")
+                    return (True, response)
+                # Return a dict of the validated response
+                response_valid = self.schema[method](**response).dict()
+                # Convert the response to a format that we can use
+                response_converted = self.convert_spec(response_valid, method)
+                return (True, response_converted)
             except ValidationError as e:
                 self.log.error(f"Could not validate response: {e}")
                 return (False, e)
@@ -64,7 +92,7 @@ class BaseExchange(object):
     def cancel_trade(self, trade_id):
         raise NotImplementedError
 
-    def get_position_info(self, asset_id):
+    def get_position_info(self, symbol):
         raise NotImplementedError
 
     def get_all_positions(self):

core/exchanges/alpaca.py

@@ -133,19 +133,19 @@ class AlpacaExchange(BaseExchange):
     def cancel_trade(self, trade_id):
         pass
 
-    def get_position_info(self, asset_id):
-        success, position = self.call("get_open_position", asset_id)
+    def get_position_info(self, symbol):
+        success, position = self.call("get_open_position", symbol)
         if not success:
             return (success, position)
         return (True, position)
 
     def get_all_positions(self):
         items = []
-        success, positions = self.call("get_all_positions")
+        success, response = self.call("get_all_positions")
         if not success:
-            return (success, positions)
+            return (success, response)
 
-        for item in positions["itemlist"]:
+        for item in response["itemlist"]:
             item["account_id"] = self.account.id
             item["unrealized_pl"] = float(item["unrealized_pl"])
             items.append(item)

core/exchanges/oanda.py

@@ -1,5 +1,6 @@
 from oandapyV20 import API
 from oandapyV20.endpoints import accounts, orders, positions, trades
+from pydantic import ValidationError
 
 from core.exchanges import BaseExchange
 from core.lib.schemas import oanda_s
@@ -18,7 +19,11 @@ class OANDAExchange(BaseExchange):
             self.log.debug(f"Response: {response}")
             return (False, f"Method cannot be validated: {method}")
         try:
-            return (True, self.schema[method](**response).dict())
+            # Return a dict of the validated response
+            response_valid = self.schema[method](**response).dict()
+            # Convert the response to a format that we can use
+            response_converted = self.convert_spec(response_valid, method)
+            return (True, response_converted)
         except ValidationError as e:
             self.log.error(f"Could not validate response: {e}")
             return (False, e)
@@ -66,16 +71,21 @@ class OANDAExchange(BaseExchange):
     def cancel_trade(self, trade_id):
         raise NotImplementedError
 
-    def get_position_info(self, asset_id):
-        r = positions.PositionDetails(self.account_id, asset_id)
+    def get_position_info(self, symbol):
+        r = positions.PositionDetails(self.account_id, symbol)
         self.client.request(r)
         return r.response
 
     def get_all_positions(self):
+        items = []
         r = positions.OpenPositions(accountID=self.account_id)
         success, response = self.call("OpenPositions", r)
         if not success:
             return (success, response)
 
         print("Positions", response)
-        return (True, [])
+        for item in response["itemlist"]:
+            item["account_id"] = self.account.id
+            item["unrealized_pl"] = float(item["unrealized_pl"])
+            items.append(item)
+        return (True, items)