Merge pull request #14 from bandprotocol/BST-550-refactor-adapter

Author: warittornc

adapter/__init__.py

@@ -1,39 +1 @@
-from abc import ABC, abstractmethod
-from importlib import import_module
-from typing import Any, Dict
-
-
-class Adapter(ABC):
-    @abstractmethod
-    def phrase_input(self, request: Dict):
-        pass
-
-    @abstractmethod
-    def verify_output(self, input: Any, output: Any):
-        pass
-
-    @abstractmethod
-    def phrase_output(self, output: Any):
-        pass
-
-    @abstractmethod
-    async def call(self, input: Any):
-        pass
-
-    async def unified_call(self, request: Dict):
-        input = self.phrase_input(request)
-        output = await self.call(input)
-        self.verify_output(input, output)
-        return self.phrase_output(output)
-
-
-def init_adapter(adapter_type: str, adapter_name: str) -> Adapter:
-    # check adapter configuration
-    if not adapter_type:
-        raise Exception("MISSING 'ADAPTER_TYPE' ENV")
-    if not adapter_name:
-        raise Exception("MISSING 'ADAPTER_NAME' ENV")
-
-    module = import_module(f"adapter.{adapter_type}.{adapter_name}".lower())
-    AdapterClass = getattr(module, "".join([part.capitalize() for part in adapter_name.split("_")]))
-    return AdapterClass()
+from .base import Adapter, init_adapter

adapter/base.py

@@ -0,0 +1,71 @@
+from abc import ABC, abstractmethod
+from importlib import import_module
+from typing import Any, Dict
+
+
+class Adapter(ABC):
+    @abstractmethod
+    def parse_input(self, request: Dict[str, Any]) -> Any:
+        """This function parses the data retrieved from the request.
+
+        Args:
+            request: The request response as a dictionary.
+
+        Returns:
+            A parsed set of data.
+        """
+        pass
+
+    @abstractmethod
+    def verify_output(self, input_: Any, output: Any) -> None:
+        """This function verifies the adapter's output to assure a proper response can be given.
+
+        If the output fails verification, this function should raise an exception.
+
+        Args:
+            input_: The request input data from BandChain.
+            output: The output to be returned to the data source requestor.
+        """
+        pass
+
+    @abstractmethod
+    def parse_output(self, output: Any) -> Any:
+        """This function parses the output retrieved from the adapter's set endpoint.
+
+        Args:
+            output: Output from the adapter's endpoint.
+
+        Returns:
+            The parsed output to be sent back to the data source.
+        """
+        pass
+
+    @abstractmethod
+    async def call(self, input_: Any) -> Any:
+        """This function calls the adapter's set endpoint to retrieve the requested data.
+
+        Args:
+            input_: The input from request from the data source.
+
+        Returns:
+            The raw data from the adapter's endpoint.
+        """
+        pass
+
+    async def unified_call(self, request: Dict[str, Any]) -> Any:
+        input_ = self.parse_input(request)
+        output = await self.call(input_)
+        self.verify_output(input_, output)
+        return self.parse_output(output)
+
+
+def init_adapter(adapter_type: str, adapter_name: str) -> Adapter:
+    # check adapter configuration
+    if not adapter_type:
+        raise Exception("MISSING 'ADAPTER_TYPE' ENV")
+    if not adapter_name:
+        raise Exception("MISSING 'ADAPTER_NAME' ENV")
+
+    module = import_module(f"adapter.{adapter_type}.{adapter_name}".lower())
+    AdapterClass = getattr(module, "".join([part.capitalize() for part in adapter_name.split("_")]))
+    return AdapterClass()

adapter/mock/mock.py

@@ -1,15 +1,17 @@
+from typing import Any
+
 from adapter import Adapter
 
 
 class Mock(Adapter):
-    def phrase_input(self, _) -> str:
+    def parse_input(self, _) -> Any:
         return "mock_input"
 
-    def verify_output(self, input: str, output: str):
-        return True
+    def verify_output(self, input_: str, output: str) -> None:
+        pass
 
-    def phrase_output(self, _) -> str:
+    def parse_output(self, _) -> Any:
         return "mock_output"
 
-    async def call(self, _) -> str:
+    async def call(self, _) -> Any:
         return "called"

adapter/standard_crypto_price/__init__.py

@@ -1,42 +1 @@
-from abc import abstractmethod
-from adapter import Adapter
-from typing import TypedDict, List, Dict
 
-
-class Price(TypedDict):
-    symbol: str
-    price: float
-    timestamp: int
-
-
-class Request(TypedDict):
-    symbols: str
-
-
-class Input(TypedDict):
-    symbols: List[str]
-
-
-class Output(TypedDict):
-    prices: List[Price]
-
-
-class Response(TypedDict):
-    prices: List[Price]
-
-
-class StandardCryptoPrice(Adapter):
-    def phrase_input(self, request: Dict) -> Input:
-        symbols = [symbol.strip() for symbol in request.get("symbols", "").split(",")]
-        return Input(symbols=symbols)
-
-    def verify_output(self, input: Input, output: Output):
-        if len(input["symbols"]) != len(output["prices"]):
-            raise Exception(f"length of inputs and outputs are not the same.")
-
-    def phrase_output(self, output: Output) -> Response:
-        return Response(output)
-
-    @abstractmethod
-    async def call(self, input: Input) -> Output:
-        pass

adapter/standard_crypto_price/base.py

@@ -0,0 +1,43 @@
+from abc import abstractmethod
+from typing import TypedDict, List, Dict
+
+from adapter import Adapter
+
+
+class Price(TypedDict):
+    symbol: str
+    price: float
+    timestamp: int
+
+
+class Request(TypedDict):
+    symbols: str
+
+
+class Input(TypedDict):
+    symbols: List[str]
+
+
+class Output(TypedDict):
+    prices: List[Price]
+
+
+class Response(TypedDict):
+    prices: List[Price]
+
+
+class StandardCryptoPrice(Adapter):
+    def parse_input(self, request: Dict) -> Input:
+        symbols = [symbol.strip() for symbol in request.get("symbols", "").split(",")]
+        return Input(symbols=symbols)
+
+    def verify_output(self, input_: Input, output: Output):
+        if len(input_["symbols"]) != len(output["prices"]):
+            raise Exception(f"length of inputs and outputs are not the same.")
+
+    def parse_output(self, output: Output) -> Response:
+        return Response(prices=output["prices"])
+
+    @abstractmethod
+    async def call(self, input_: Input) -> Output:
+        pass

adapter/standard_crypto_price/coin_market_cap.py

@@ -1,8 +1,10 @@
-from adapter.standard_crypto_price import StandardCryptoPrice, Input, Output
-from typing import Dict
+import os
 from datetime import datetime, timezone
+from typing import Dict
+
 import httpx
-import os
+
+from adapter.standard_crypto_price.base import StandardCryptoPrice, Input, Output
 
 
 class CoinMarketCap(StandardCryptoPrice):
@@ -223,12 +225,12 @@ def __init__(self):
             "PSI": "nexus-protocol",
         }
 
-    async def call(self, input: Input) -> Output:
+    async def call(self, input_: Input) -> Output:
         client = httpx.AsyncClient()
         response = await client.request(
             "GET",
             self.api_url,
-            params={"slug": ",".join([self.symbols_map.get(symbol, symbol) for symbol in input["symbols"]])},
+            params={"slug": ",".join([self.symbols_map.get(symbol, symbol) for symbol in input_["symbols"]])},
             headers={
                 "X-CMC_PRO_API_KEY": self.api_key,
             },
@@ -252,6 +254,4 @@ async def call(self, input: Input) -> Output:
             for data in response_json["data"].values()
         ]
 
-        return Output(
-            prices=prices,
-        )
+        return Output(prices=prices)

adapter/standard_crypto_price/crypto_compare.py

@@ -1,10 +1,10 @@
-import httpx
 import os
-from typing import Dict
 from datetime import datetime
+from typing import Dict
 
+import httpx
 
-from adapter.standard_crypto_price import StandardCryptoPrice, Input, Output
+from adapter.standard_crypto_price.base import StandardCryptoPrice, Input, Output
 
 
 class CryptoCompare(StandardCryptoPrice):
@@ -13,20 +13,20 @@ class CryptoCompare(StandardCryptoPrice):
     symbols_map: Dict[str, str] = None
     symbols_map_back: Dict[str, str] = None
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.api_key = os.getenv("CRYPTO_COMPARE_API_KEY", None)
         self.symbols_map = {
             "CUSD": "CELOUSD",
         }
         self.symbols_map_back = {v: k for k, v in self.symbols_map.items()}
 
-    async def call(self, input: Input) -> Output:
+    async def call(self, input_: Input) -> Output:
         client = httpx.AsyncClient()
         response = await client.request(
             "GET",
             self.api_url,
             params={
-                "fsyms": ",".join([self.symbols_map.get(symbol, symbol) for symbol in input["symbols"]]),
+                "fsyms": ",".join([self.symbols_map.get(symbol, symbol) for symbol in input_["symbols"]]),
                 "tsyms": "USD",
             },
             headers={"Authorization": f"Apikey " + self.api_key},
@@ -44,6 +44,4 @@ async def call(self, input: Input) -> Output:
             for symbol, value in response_json.items()
         ]
 
-        return Output(
-            prices=prices,
-        )
+        return Output(prices=prices)

adapter/standard_crypto_price/internal_service.py

@@ -1,7 +1,8 @@
-import httpx
 import os
 
-from adapter.standard_crypto_price import StandardCryptoPrice, Input, Output
+import httpx
+
+from adapter.standard_crypto_price.base import StandardCryptoPrice, Input, Output
 
 
 class InternalService(StandardCryptoPrice):
@@ -11,12 +12,12 @@ class InternalService(StandardCryptoPrice):
     def __init__(self):
         self.api_url = os.getenv("API_URL", None)
 
-    async def call(self, input: Input) -> Output:
+    async def call(self, input_: Input) -> Output:
         client = httpx.AsyncClient()
         response = await client.request(
             "GET",
             self.api_url,
-            params={"symbols": ",".join(input["symbols"])},
+            params={"symbols": ",".join(input_["symbols"])},
         )
 
         response.raise_for_status()
@@ -31,6 +32,4 @@ async def call(self, input: Input) -> Output:
             for item in response_json["prices"]
         ]
 
-        return Output(
-            prices=prices,
-        )
+        return Output(prices=prices)

adapter/standard_crypto_price/template.py

@@ -1,14 +1,15 @@
-from adapter.standard_crypto_price import StandardCryptoPrice, Input, Output
 import os
 
+from adapter.standard_crypto_price.base import StandardCryptoPrice, Input, Output
+
 
 class Template(StandardCryptoPrice):
     api_url: str
     api_key: str
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.api_url = os.getenv("API_URL", None)
         self.api_key = os.getenv("API_KEY", None)
 
-    async def call(self, input: Input) -> Output:
-        return Output()
+    async def call(self, input_: Input) -> Output:
+        pass