Fixed some linting issues.

mango/orders.py

@@ -222,34 +222,32 @@ class OrderBook:
     def __init__(self, symbol: str, lot_size_converter: LotSizeConverter, bids: typing.Sequence[Order], asks: typing.Sequence[Order]) -> None:
         self.symbol: str = symbol
         self.__lot_size_converter: LotSizeConverter = lot_size_converter
-        self.bids: typing.Sequence[Order] = bids
+        self.__bids: typing.Sequence[Order] = []
-        self.asks: typing.Sequence[Order] = asks
+        self.__asks: typing.Sequence[Order] = []
+        self.bids = bids
+        self.asks = asks
 
     @property
     def bids(self) -> typing.Sequence[Order]:
-        return self._bids
+        return self.__bids
 
     @bids.setter
-    def bids(self, bids: typing.Sequence[Order]):
+    def bids(self, bids: typing.Sequence[Order]) -> None:
         """ Sort bids high to low, so best bid is at index 0 """
         bids_list: typing.List[Order] = list(bids)
-        print(f'list of bids: {bids_list}')
         bids_list.sort(key=lambda order: order.id, reverse=True)
-        print(f'list of sorted bids: {bids_list}')
+        self.__bids = bids_list
-        # bids_list.sort(key=lambda order: order.price, reverse=True)
-        self._bids = bids_list
 
     @property
     def asks(self) -> typing.Sequence[Order]:
-        return self._asks
+        return self.__asks
 
     @asks.setter
-    def asks(self, asks: typing.Sequence[Order]):
+    def asks(self, asks: typing.Sequence[Order]) -> None:
         """ Sets asks low to high, so best ask is at index 0"""
         asks_list: typing.List[Order] = list(asks)
         asks_list.sort(key=lambda order: order.id)
-        # asks_list.sort(key=lambda order: order.price)
+        self.__asks = asks_list
-        self._asks = asks_list
 
     # The top bid is the highest price someone is willing to pay to BUY
     @property

tests/fakes.py

@@ -133,10 +133,11 @@ def fake_wallet() -> mango.Wallet:
 def fake_order(price: Decimal = Decimal(1), quantity: Decimal = Decimal(1), side: mango.Side = mango.Side.BUY, order_type: mango.OrderType = mango.OrderType.LIMIT) -> mango.Order:
     return mango.Order.from_basic_info(side=side, price=price, quantity=quantity, order_type=order_type)
 
+
 # serum ID structure - 16-byte 'int': low 8 bytes is a sequence number, high 8 bytes is price
 def fake_order_id(index: int, price: int) -> int:
     # price needs to be max of 64bit/8bytes, considering signed int is not permitted
-    if index > 2**64-1 or price > 2**64-1:
+    if index > (2 ** 64) - 1 or price > (2 ** 64) - 1:
         raise ValueError(f"Provided index '{index}' or price '{price}' is bigger than 8 bytes int")
     index_bytes = index.to_bytes(8, byteorder='big', signed=False)
     price_bytes = price.to_bytes(8, byteorder='big', signed=False)

tests/test_orderbook.py

@@ -1,12 +1,12 @@
 import random
-
+import typing
-from mango.orders import Order
 
 from .context import mango
+
+from decimal import Decimal
+
 from .fakes import fake_order_id
 
-from typing import Sequence
-from decimal import Decimal
 
 def test_order_book_sides_sorted_by_price() -> None:
     bids_side = _construct_order_book_side(mango.Side.BUY, 5)
@@ -15,6 +15,7 @@ def test_order_book_sides_sorted_by_price() -> None:
     assert sorted(bids_side, key=lambda o: o.price, reverse=True) == order_book.bids
     assert sorted(asks_side, key=lambda o: o.price, reverse=False) == order_book.asks
 
+
 def test_orderbook_top_bids_and_asks() -> None:
     bids = _construct_order_book_side(mango.Side.BUY, 7)
     asks = _construct_order_book_side(mango.Side.SELL, 7)
@@ -45,37 +46,35 @@ def test_orderbook_spread() -> None:
     orderBook = _construct_order_book(bids=bids, asks=asks)
     assert orderBook.spread == _get_order(asks).price - _get_order(bids, -1).price
 
+
 # ASK is SELL, BID is BUY
-def _construct_order_book_side(askOrBidSide: mango.Side, size: int) -> Sequence[mango.Order]:
+def _construct_order_book_side(askOrBidSide: mango.Side, size: int) -> typing.Sequence[mango.Order]:
-    random_prices: list[(int,int)] = list(map(
+    result_orders: typing.List[mango.Order] = []
-        lambda x, y: (x, y),
+    for index, price in enumerate(random.sample(range(1, 1000), size)):
-        range (1, size+1),
-        random.sample(range(1, 1000), size)
-    ))
-    result_orders: Sequence[mango.Order] = []
-    for index, price in random_prices:
         constructed_id = fake_order_id(index, price)
-        order = Order.from_ids(
+        order = mango.Order.from_ids(
             id=constructed_id,
             client_id=0,
             side=askOrBidSide,
-            price=price,
+            price=Decimal(price),
-            quantity=random.randint(1, 100),
+            quantity=Decimal(random.randint(1, 100)),
         )
         result_orders.append(order)
     return result_orders
 
+
 def _construct_order_book(
-    bids: Sequence[mango.Order],
+    bids: typing.Sequence[mango.Order],
-    asks: Sequence[mango.Order]
+    asks: typing.Sequence[mango.Order]
 ) -> mango.OrderBook:
     # construct orderbook
     return mango.OrderBook(
         symbol='TEST',
-        lot_size_converter=None,
+        lot_size_converter=mango.NullLotSizeConverter(),
         bids=bids,
         asks=asks
     )
 
-def _get_order(orders: Sequence[mango.Order], index: int = 0) -> Order:
+
+def _get_order(orders: typing.Sequence[mango.Order], index: int = 0) -> mango.Order:
     return sorted(orders, key=lambda order: order.price)[index]