Fix: merged responses.order.py into responses.asset.py, to prevent import errors.

Also optimized imports.

Author: dehidehidehi

open_sea_v1/endpoints/client.py

@@ -74,12 +74,12 @@ class BaseClient(ABC):
     client_params:
         ClientParams instance.
 
-    _rate_limit: int = 18
+    _rate_limit: int
         Rate limit for the API is 20 when you have an API key.
         However, you run the risk of losing a a few seconds if you get throttled by the server.
         After some testing, it seems 18 is the sweet spot.
 
-    _concurrency_limit: int = 9
+    _concurrency_limit: int
         Concurrency limit: number of simultaneous connections at a time.
         Best results obtained by using the largest multiple of _rate_limit, or second largest multiple.
         Otherwise you risk more throttling on the serverside than necessary.
@@ -117,13 +117,13 @@ def get_parsed_pages(self, flat: bool = True) -> list:
         if sys.platform == 'win32':
             asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())  # prevents closed loops errors on windows
         self._latest_json_response = None  # reset: required for pagination function
-        results = asyncio.run(self._aget_parsed_pages())  # implement async generator so i can use yield from
+        results = asyncio.run(self._aget_parsed_pages())
         if not flat:
             return results
         flattened = list(chain.from_iterable(results))
         return flattened
 
-    async def _aget_parsed_pages(self) -> list[list[Type[BaseResponse]]]:  # cant be a synchronous generator
+    async def _aget_parsed_pages(self) -> list[list[Type[BaseResponse]]]:
         all_parsed_jsons = list()
 
         async with RateLimiter(rate_limit=self._rate_limit, concurrency_limit=self._concurrency_limit) as rate_limiter:
@@ -136,6 +136,7 @@ async def _aget_parsed_pages(self) -> list[list[Type[BaseResponse]]]:  # cant be
 
     async def _async_get_pages_jsons(self, session, *, rate_limiter: RateLimiter) -> Optional[list[dict]]:
         responses = list()
+        processed_pages = 0
         while self._remaining_pages():
 
             self.client_params.offset += self.client_params.page_size
@@ -147,10 +148,12 @@ async def _async_get_pages_jsons(self, session, *, rate_limiter: RateLimiter) ->
                 json_resp = await resp.json()
                 self._latest_json_response = json_resp
                 self.client_params._decrement_max_pages_attr()
+                processed_pages += 1
 
             if potential_error_occurred := isinstance(json_resp, dict) and 'detail' in json_resp.keys():
                 raise ConnectionError(f'{(error_msg := json_resp["detail"])}')
 
+            logger.info(f'Fetched page #{processed_pages} (~{self.client_params.page_size} elements)')
             responses.append(json_resp)
         return responses
 

open_sea_v1/endpoints/orders.py

@@ -4,7 +4,7 @@
 from open_sea_v1.endpoints.abc import BaseEndpoint
 from open_sea_v1.endpoints.client import BaseClient, ClientParams
 from open_sea_v1.endpoints.urls import EndpointURLS
-from open_sea_v1.responses.order import OrderResponse
+from open_sea_v1.responses.asset import OrderResponse
 
 
 @dataclass

open_sea_v1/endpoints/tests/test_client.py

@@ -1,4 +1,3 @@
-from itertools import chain
 from os import environ
 from unittest import TestCase, skipIf
 

open_sea_v1/helpers/rate_limiter.py

@@ -3,8 +3,6 @@
 import time
 from contextlib import asynccontextmanager
 
-# GLOBAL_QUEUE = None  # singleton queue
-
 
 class RateLimiter:
     """
@@ -19,10 +17,6 @@ def __init__(self, rate_limit: int, concurrency_limit: int) -> None:
             raise ValueError('concurrent limit must be non zero positive number')
 
         self.rate_limit = rate_limit
-        # global GLOBAL_QUEUE
-        # if not GLOBAL_QUEUE:
-        #     GLOBAL_QUEUE = asyncio.Queue(rate_limit)
-        # self.tokens_queue = GLOBAL_QUEUE
         self.tokens_queue = asyncio.Queue(rate_limit)
         self.tokens_consumer_task = asyncio.create_task(self.consume_tokens())
         self.semaphore = asyncio.Semaphore(concurrency_limit)

open_sea_v1/helpers/testing_class.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from itertools import chain
 from typing import Type
 from unittest import TestCase
 

open_sea_v1/responses/asset.py

@@ -74,6 +74,72 @@ def __post_init__(self):
         self.external_link = self._contract['external_link']
 
 
+@dataclass
+class OrderResponse(BaseResponse):
+    _json: dict
+
+    def __str__(self):
+        return f"{self.id=}" if self.id else f"{self.order_hash=}"
+
+    def __post_init__(self):
+        self._set_optional_attrs()
+        self._set_common_attrs()
+
+    @property
+    def asset(self) -> 'AssetResponse':
+        return AssetResponse(self._json['asset'])
+
+    def _set_optional_attrs(self):
+        """Depending on the endpoint you use, the Order response object will contain optional attributes."""
+        self.id: Optional = self._json.get('id')  # id is only provided if you use the OrdersEndpoint
+        self.asset_bundle = self._json.get('asset_bundle')
+
+    def _set_common_attrs(self):
+        self.order_hash = self._json.get('order_hash')
+        self.created_date = self._json['created_date']
+        self.closing_date = self._json['closing_date']
+        self.closing_extendable = self._json['closing_extendable']
+        self.expiration_time = self._json['expiration_time']
+        self.listing_time = self._json['listing_time']
+        self.order_hash = self._json['order_hash']
+        self.exchange = self._json['exchange']
+        self.current_price = self._json['current_price']
+        self.current_bounty = self._json['current_bounty']
+        self.bounty_multiple = self._json['bounty_multiple']
+        self.maker_relayer_fee = self._json['maker_relayer_fee']
+        self.taker_relayer_fee = self._json['taker_relayer_fee']
+        self.maker_protocol_fee = self._json['maker_protocol_fee']
+        self.taker_protocol_fee = self._json['taker_protocol_fee']
+        self.maker_referrer_fee = self._json['maker_referrer_fee']
+        self.fee_method = self._json['fee_method']
+        self.side = self._json['side']
+        self.sale_kind = self._json['sale_kind']
+        self.target = self._json['target']
+        self.how_to_call = self._json['how_to_call']
+        self.calldata = self._json['calldata']
+        self.replacement_pattern = self._json['replacement_pattern']
+        self.static_target = self._json['static_target']
+        self.static_extradata = self._json['static_extradata']
+        self.payment_token = self._json['payment_token']
+        self.base_price = self._json['base_price']
+        self.extra = self._json['extra']
+        self.quantity = self._json['quantity']
+        self.salt = self._json['salt']
+        self.v = self._json['v']
+        self.r = self._json['r']
+        self.s = self._json['s']
+        self.approved_on_chain = self._json['approved_on_chain']
+        self.cancelled = self._json['cancelled']
+        self.finalized = self._json['finalized']
+        self.marked_invalid = self._json['marked_invalid']
+        self.prefixed_hash = self._json['prefixed_hash']
+        self.metadata: dict = self._json['metadata']
+        self.maker: dict = self._json['maker']
+        self.taker: dict = self._json['taker']
+        self.fee_recipient: dict = self._json['fee_recipient']
+        self.payment_token_contract: dict = self._json['payment_token_contract']
+
+
 @dataclass
 class AssetResponse(BaseResponse):
     _json: dict
@@ -112,7 +178,6 @@ def _set_common_attrs(self):
         self.is_presale = self._json.get("is_presale")
         self.listing_date = self._json.get("listing_date")
         self.top_bid = self._json.get("top_bid")
-        self.sell_orders = self._json.get("sell_orders")
 
     @property
     def asset_contract(self) -> _Contract:
@@ -140,6 +205,12 @@ def last_sale(self) -> Optional[_LastSale]:
     def collection(self):
         return CollectionResponse(self._json['collection'])
 
+    @property
+    def sell_orders(self) -> Optional[list[OrderResponse]]:
+        if sell_orders := self._json.get('sell_orders'):
+            return [OrderResponse(order) for order in sell_orders]
+        return None
+
     @property
     def creator(self) -> Optional[dict]:
         return self._json.get('creator')

open_sea_v1/responses/order.py

@@ -1,76 +1,5 @@
 """
 Assigns attributes to dictionnary values for easier object navigation.
 """
-from dataclasses import dataclass
 
-from open_sea_v1.responses.abc import BaseResponse
-from open_sea_v1.responses.asset import AssetResponse
 
-
-@dataclass
-class OrderResponse(BaseResponse):
-    _json: dict
-
-    def __str__(self):
-        return f"order_id={self.id}"
-
-    def __post_init__(self):
-        self._set_common_attrs()
-        self._set_optional_attrs()
-
-    def _set_common_attrs(self):
-        self.id = self._json['id']
-        self.asset_bundle = self._json['asset_bundle']
-        self.created_date = self._json['created_date']
-        self.closing_date = self._json['closing_date']
-        self.closing_extendable = self._json['closing_extendable']
-        self.expiration_time = self._json['expiration_time']
-        self.listing_time = self._json['listing_time']
-        self.order_hash = self._json['order_hash']
-        self.exchange = self._json['exchange']
-        self.current_price = self._json['current_price']
-        self.current_bounty = self._json['current_bounty']
-        self.bounty_multiple = self._json['bounty_multiple']
-        self.maker_relayer_fee = self._json['maker_relayer_fee']
-        self.taker_relayer_fee = self._json['taker_relayer_fee']
-        self.maker_protocol_fee = self._json['maker_protocol_fee']
-        self.taker_protocol_fee = self._json['taker_protocol_fee']
-        self.maker_referrer_fee = self._json['maker_referrer_fee']
-        self.fee_method = self._json['fee_method']
-        self.side = self._json['side']
-        self.sale_kind = self._json['sale_kind']
-        self.target = self._json['target']
-        self.how_to_call = self._json['how_to_call']
-        self.calldata = self._json['calldata']
-        self.replacement_pattern = self._json['replacement_pattern']
-        self.static_target = self._json['static_target']
-        self.static_extradata = self._json['static_extradata']
-        self.payment_token = self._json['payment_token']
-        self.base_price = self._json['base_price']
-        self.extra = self._json['extra']
-        self.quantity = self._json['quantity']
-        self.salt = self._json['salt']
-        self.v = self._json['v']
-        self.r = self._json['r']
-        self.s = self._json['s']
-        self.approved_on_chain = self._json['approved_on_chain']
-        self.cancelled = self._json['cancelled']
-        self.finalized = self._json['finalized']
-        self.marked_invalid = self._json['marked_invalid']
-        self.prefixed_hash = self._json['prefixed_hash']
-        self.metadata: dict = self._json['metadata']
-        self.maker: dict = self._json['maker']
-        self.taker: dict = self._json['taker']
-        self.fee_recipient: dict = self._json['fee_recipient']
-        self.payment_token_contract: dict = self._json['payment_token_contract']
-
-    @property
-    def asset(self) -> AssetResponse:
-        return AssetResponse(self._json['asset'])
-
-    def _set_optional_attrs(self):
-        """
-        Most asset responses are alike, but some are returned with less information.
-        To avoid raising KeyErrors, we will use the .get method when setting these attributes.
-        """
-        ...

open_sea_v1/responses/tests/_response_helpers.py

@@ -1,4 +1,3 @@
-from itertools import chain
 from typing import Type
 from unittest import TestCase