Updating pyth classes to use dataclass

This makes the code easier to read and makes the comparison less janky.

* Updating PythPriceInfo to use datclass and flake8 updates
* Updating PythPriceComponent to use a datclass
* Updating PythPriceAccount tests to use dataclass
* Update the binary bits to use base64 encoded bytes for brevity

Nice review suggestion from @tony-ricciardi. Not yet using dataclass
with PythProductAccount as there is some magic with the _prices attribute
and the properties without full coverage yet. The tests were janky and I'll
figure it out later when adding coverage for the various update bits.

Author: Jeff Schroeder

pythclient/pythaccounts.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
-from typing import List, Dict, Tuple, Optional, Any
+from typing import List, Dict, Tuple, Optional, Any, ClassVar
 import base64
 from enum import Enum
+from dataclasses import dataclass, field
 import struct
 
 from loguru import logger
@@ -205,7 +206,6 @@ class PythProductAccount(PythAccount):
         first_price_account_key (SolanaPublicKey): the public key of the first price account (the price accounts form a linked list)
         attrs (dict): a dictionary of metadata attributes
     """
-
     def __init__(self, key: SolanaPublicKey, solana: SolanaClient) -> None:
         super().__init__(key, solana)
         self._prices: Optional[Dict[PythPriceType, PythPriceAccount]] = None
@@ -229,7 +229,6 @@ def symbol(self) -> str:
         """
         Gets this account's symbol, or 'Unknown' if there is no 'symbol' attribute.
         """
-
         return self.attrs.get("symbol", "Unknown")
 
     async def get_prices(self) -> Dict[PythPriceType, PythPriceAccount]:
@@ -258,7 +257,10 @@ async def refresh_prices(self) -> Dict[PythPriceType, PythPriceAccount]:
         self._prices = prices
         return prices
 
-    async def check_price_changes(self, update_accounts: bool = True) -> Tuple[List[PythPriceAccount], List[PythPriceAccount]]:
+    async def check_price_changes(
+        self,
+        update_accounts: bool = True
+    ) -> Tuple[List[PythPriceAccount], List[PythPriceAccount]]:
         """
         Checks for changes to the list of price accounts of this product.
 
@@ -351,6 +353,7 @@ def __iter__(self):
                 yield key, val
 
 
+@dataclass
 class PythPriceInfo:
     """
     Contains price information.
@@ -365,15 +368,18 @@ class PythPriceInfo:
         exponent (int): the power-of-10 order of the price
     """
 
-    LENGTH = 32
+    LENGTH: ClassVar[int] = 32
 
-    def __init__(self, raw_price: int, raw_confidence_interval: int, price_status: PythPriceStatus, slot: int, exponent: int) -> None:
-        self.raw_price = raw_price
-        self.raw_confidence_interval = raw_confidence_interval
-        self.price_status = price_status
-        self.slot = slot
-        self.exponent = exponent
+    raw_price: int
+    raw_confidence_interval: int
+    price_status: PythPriceStatus
+    slot: int
+    exponent: int
 
+    price: float = field(init=False)
+    confidence_interval: float = field(init=False)
+
+    def __post_init__(self):
         self.price = self.raw_price * (10 ** self.exponent)
         self.confidence_interval = self.raw_confidence_interval * \
             (10 ** self.exponent)
@@ -401,11 +407,8 @@ def __str__(self) -> str:
     def __repr__(self) -> str:
         return str(self)
 
-    def __iter__(self):
-        for key, val in self.__dict__.items():
-            yield key, val
-
 
+@dataclass
 class PythPriceComponent:
     """
     Represents a price component. This is the individual prices each
@@ -421,13 +424,12 @@ class PythPriceComponent:
             in this price component
     """
 
-    LENGTH = SolanaPublicKey.LENGTH + 2 * PythPriceInfo.LENGTH
+    LENGTH: ClassVar[int] = SolanaPublicKey.LENGTH + 2 * PythPriceInfo.LENGTH
 
-    def __init__(self, publisher_key: SolanaPublicKey, last_aggregate_price_info: PythPriceInfo, latest_price_info: PythPriceInfo, exponent: int) -> None:
-        self.publisher_key = publisher_key
-        self.last_aggregate_price_info = last_aggregate_price_info
-        self.latest_price_info = latest_price_info
-        self.exponent = exponent
+    publisher_key: SolanaPublicKey
+    last_aggregate_price_info: PythPriceInfo
+    latest_price_info: PythPriceInfo
+    exponent: int
 
     @staticmethod
     def deserialise(buffer: bytes, offset: int = 0, *, exponent: int) -> Optional[PythPriceComponent]:
@@ -449,12 +451,6 @@ def deserialise(buffer: bytes, offset: int = 0, *, exponent: int) -> Optional[Py
         latest_price = PythPriceInfo.deserialise(buffer, offset, exponent=exponent)
         return PythPriceComponent(key, last_aggregate_price, latest_price, exponent)
 
-    def __iter__(self):
-        for key, val in self.__dict__.items():
-            if isinstance(val, PythPriceInfo):
-                val = dict(val)
-            yield key, val
-
 
 class PythPriceAccount(PythAccount):
     """
@@ -528,22 +524,22 @@ def update_from(self, buffer: bytes, *, version: int, offset: int = 0) -> None:
         """
         if version == _VERSION_2:
             price_type, exponent, num_components = struct.unpack_from("<IiI", buffer, offset)
-            offset += 16 # struct.calcsize("IiII") (last I is the number of quoters that make up the aggregate)
+            offset += 16  # struct.calcsize("IiII") (last I is the number of quoters that make up the aggregate)
             last_slot, valid_slot = struct.unpack_from("<QQ", buffer, offset)
-            offset += 16 # QQ
+            offset += 16  # QQ
             derivations = list(struct.unpack_from("<6q", buffer, offset))
             self.derivations = dict((type_, derivations[type_.value - 1]) for type_ in [TwEmaType.TWACVALUE, TwEmaType.TWAPVALUE])
-            offset += 48 # 6q
+            offset += 48  # 6q
             # All drv*_ fields sans min_publishers are currently unused
             _, min_publishers = struct.unpack_from("<qQ", buffer, offset)
-            offset += 16 # <qQ
+            offset += 16  # <qQ
             product_account_key_bytes, next_price_account_key_bytes = struct.unpack_from("32s32s", buffer, offset)
-            offset += 96 # 32s32s32s
+            offset += 96  # 32s32s32s
         elif version == _VERSION_1:
             price_type, exponent, num_components, _, last_slot, valid_slot, product_account_key_bytes, next_price_account_key_bytes, aggregator_key_bytes = struct.unpack_from(
                 "<IiIIQQ32s32s32s", buffer, offset)
             self.derivations = {}
-            offset += 128 # struct.calcsize("<IiIIQQ32s32s32s")
+            offset += 128  # struct.calcsize("<IiIIQQ32s32s32s")
         else:
             assert False
 

tests/test_mapping_account.py

@@ -1,3 +1,4 @@
+import base64
 import pytest
 
 from pythclient.pythaccounts import PythMappingAccount, _VERSION_2
@@ -20,23 +21,14 @@ def mapping_account_bytes():
 
     Render those into a pasteable form with:
 
-        print(list(product_account_bytes))
+        print(base64.b6encode(product_account_bytes))
 
     """
-    return bytes(
-        [
-            3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            72, 214, 3, 61, 115, 62, 39, 149, 12, 46, 3, 81, 226, 80,
-            84, 145, 205, 145, 84, 130, 79, 113, 109, 149, 19, 81, 76,
-            116, 185, 249, 143, 88, 200, 12, 11, 20, 138, 186, 153, 75,
-            37, 102, 234, 84, 167, 143, 240, 142, 250, 61, 94, 14, 195,
-            208, 206, 234, 12, 250, 160, 63, 236, 37, 238, 162, 53, 21,
-            179, 134, 30, 143, 233, 62, 95, 84, 11, 164, 7, 124, 33,
-            100, 4, 120, 43, 134, 213, 231, 128, 119, 179, 203, 253,
-            39, 49, 58, 179, 188
-        ]
-    )
+    return base64.b64decode((
+        b'AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEjWAz1zPieVDC4DUeJQVJHNkVSCT3FtlRNRT'
+        b'HS5+Y9YyAwLFIq6mUslZupUp4/wjvo9Xg7D0M7qDPqgP+wl7qI1FbOGHo/pPl9UC6QHfCFkBHgrhtXngHezy/0nMT'
+        b'qzvA=='
+    ))
 
 
 @pytest.fixture