Changes to rm-refactor-overloaded-assets-operators

Related MR: !93 (merged)

package/test_tools/__private/asset.py

@@ -21,38 +21,28 @@ class AssetBase(acp.Abstract):
     def __init__(self, amount: Union[int, float]) -> None:
         self.amount = self.__convert_amount_to_internal_representation(amount)
 
-    def __convert_amount_to_internal_representation(self, amount: Union[int, float]) -> int:
-        amount_decimal = DecimalConverter.convert(amount, precision=self.precision)
-        return int(amount_decimal * Decimal(10) ** self.precision)
+    def __str__(self) -> str:
+        return f"{self.amount / (10 ** self.precision):.{self.precision}f} {self.token}"
 
-    @classmethod
-    def __template(cls) -> dict:
-        return {
-            "amount": None,
-            "precision": cls.precision,
-            "nai": cls.nai,
-        }
+    def __repr__(self) -> str:
+        return f"Asset({self.as_nai()})"
 
-    def as_nai(self) -> dict:
-        template = self.__template().copy()
-        template["amount"] = str(self.amount)
-        return template
+    def __eq__(self, other: Any) -> bool:
+        other: AssetBase = self.__convert_to_asset(other, error_detail="compare")
+        return self.amount == other.amount
 
-    def __combine_with(self, other: Any, operator_: Union[operator.add, operator.sub]) -> AssetBase:
-        other: AssetBase = self.__convert_to_asset(other, error_detail=operator_.__name__)
+    def __lt__(self, other: Any) -> bool:
+        other: AssetBase = self.__convert_to_asset(other, error_detail="compare")
+        return self.amount < other.amount
 
+    def __neg__(self) -> AssetBase:
         result = deepcopy(self)
-        result.amount = operator_(result.amount, other.amount)
+        result.amount = -self.amount
         return result
 
     def __add__(self, other: Any) -> AssetBase:
         return self.__combine_with(other, operator.add)
 
-    def __neg__(self) -> AssetBase:
-        result = deepcopy(self)
-        result.amount = -self.amount
-        return result
-
     def __sub__(self, other: Any) -> AssetBase:
         return self.__combine_with(other, operator.sub)
 
@@ -67,33 +57,40 @@ class AssetBase(acp.Abstract):
         return self
 
     @classmethod
-    def __assert_same_template(cls, other: dict) -> Optional[NoReturn]:
-        if cls.__template().keys() != other.keys():
-            raise ParseError(f"Asset dict keys differ: {other.keys()}, when expected {cls.__template().keys()}.")
+    def __template(cls) -> dict:
+        return {
+            "amount": None,
+            "precision": cls.precision,
+            "nai": cls.nai,
+        }
 
-        if cls.nai != other["nai"]:
-            raise ParseError(f"Asset dict nai differ: `{other['nai']}`, when expected `{cls.nai}`.")
+    def as_nai(self) -> dict:
+        template = self.__template().copy()
+        template["amount"] = str(self.amount)
+        return template
 
-        if cls.precision != other["precision"]:
-            raise ParseError(f"Asset dict precision differ: `{other['precision']}`, when expected `{cls.precision}`.")
+    @classmethod
+    def _from_dict(cls, asset_as_dict: dict) -> AssetBase:
+        cls.__assert_same_template(asset_as_dict)
 
-    def __assert_same_token(self, other: AssetBase, *, error_detail: str) -> Optional[NoReturn]:
-        if self.token != other.token:
-            raise TypeError(f"Can't {error_detail} assets with different tokens: `{self.token}` and `{other.token}`.")
+        try:
+            amount = int(asset_as_dict["amount"])
+            precision = int(asset_as_dict["precision"])
+        except ValueError as exception:
+            raise ParseError("Amount and precision have to be integers.") from exception
 
-    def __lt__(self, other: Any) -> bool:
-        other: AssetBase = self.__convert_to_asset(other, error_detail="compare")
-        return self.amount < other.amount
+        return cls(amount / 10**precision)
 
-    def __eq__(self, other: Any) -> bool:
-        other: AssetBase = self.__convert_to_asset(other, error_detail="compare")
-        return self.amount == other.amount
+    def __convert_amount_to_internal_representation(self, amount: Union[int, float]) -> int:
+        amount_decimal = DecimalConverter.convert(amount, precision=self.precision)
+        return int(amount_decimal * Decimal(10) ** self.precision)
 
-    def __str__(self) -> str:
-        return f"{self.amount / (10 ** self.precision):.{self.precision}f} {self.token}"
+    def __combine_with(self, other: Any, operator_: Union[operator.add, operator.sub]) -> AssetBase:
+        other: AssetBase = self.__convert_to_asset(other, error_detail=operator_.__name__)
 
-    def __repr__(self) -> str:
-        return f"Asset({self.as_nai()})"
+        result = deepcopy(self)
+        result.amount = operator_(result.amount, other.amount)
+        return result
 
     def __convert_to_asset(self, other: Any, *, error_detail: Optional[str] = None) -> AssetBase:
         error_detail = "operate on" if error_detail is None else error_detail
@@ -117,16 +114,19 @@ class AssetBase(acp.Abstract):
         return other
 
     @classmethod
-    def _from_dict(cls, asset_as_dict: dict) -> AssetBase:
-        cls.__assert_same_template(asset_as_dict)
+    def __assert_same_template(cls, other: dict) -> Optional[NoReturn]:
+        if cls.__template().keys() != other.keys():
+            raise ParseError(f"Asset dict keys differ: {other.keys()}, when expected {cls.__template().keys()}.")
 
-        try:
-            amount = int(asset_as_dict["amount"])
-            precision = int(asset_as_dict["precision"])
-        except ValueError as exception:
-            raise ParseError("Amount and precision have to be integers.") from exception
+        if cls.nai != other["nai"]:
+            raise ParseError(f"Asset dict nai differ: `{other['nai']}`, when expected `{cls.nai}`.")
 
-        return cls(amount / 10**precision)
+        if cls.precision != other["precision"]:
+            raise ParseError(f"Asset dict precision differ: `{other['precision']}`, when expected `{cls.precision}`.")
+
+    def __assert_same_token(self, other: AssetBase, *, error_detail: str) -> Optional[NoReturn]:
+        if self.token != other.token:
+            raise TypeError(f"Can't {error_detail} assets with different tokens: `{self.token}` and `{other.token}`.")
 
 
 class Asset:
@@ -155,6 +155,23 @@ class Asset:
         precision: Final[int] = 6
         nai: Final[str] = "@@000000037"
 
+    @classmethod
+    def from_(cls, data: Union[str, dict], *, treat_dict_as_testnet_currencies: bool = True) -> AssetBase:
+        """
+        This function allows you to convert an asset from string or JSON format to the appropriate object of Asset type.
+
+        * In case of dict:
+            Nai dictionary does not hold the information about token type.
+
+            By default, treat_dict_as_testnet_currencies parameter is set to True. As a result, an Asset object will be
+            created in the testnet format. If you want to create an object in mainnet form, set it to False.
+        """
+        if isinstance(data, str):
+            return cls.__from_sting(data)
+        if isinstance(data, dict):
+            return cls.__from_dict(data, testnet_currencies=treat_dict_as_testnet_currencies)
+        raise ParseError(f"Can't convert `{type(data)}` to Asset object.")
+
     @classmethod
     def __from_sting(cls, asset_as_string: str) -> AssetBase:
         amount, token = asset_as_string.split()
@@ -183,20 +200,3 @@ class Asset:
             f"Asset with nai `{asset_as_dict['nai']}` does not exist.\n"
             f"Supported nai's are: {[asset.nai for asset in assets]}."
         )
-
-    @classmethod
-    def from_(cls, data: Union[str, dict], *, treat_dict_as_testnet_currencies: bool = True) -> AssetBase:
-        """
-        This function allows you to convert an asset from string or JSON format to the appropriate object of Asset type.
-
-        * In case of dict:
-            Nai dictionary does not hold the information about token type.
-
-            By default, treat_dict_as_testnet_currencies parameter is set to True. As a result, an Asset object will be
-            created in the testnet format. If you want to create an object in mainnet form, set it to False.
-        """
-        if isinstance(data, str):
-            return cls.__from_sting(data)
-        if isinstance(data, dict):
-            return cls.__from_dict(data, testnet_currencies=treat_dict_as_testnet_currencies)
-        raise ParseError(f"Can't convert `{type(data)}` to Asset object.")