Added various validation checks.

Fixed issue with remaining pages func.
Adjusted load methods on response parser class.
Added __str__ methods on multiple Response classes.
Fixed Traits/Last Sale in AssetResponse class .

Author: dehidehidehi

open_sea_v1/endpoints/assets.py

@@ -55,7 +55,7 @@ class AssetsEndpoint(BaseClient, BaseEndpoint):
     client_params: ClientParams = None
     asset_contract_address: Optional[list[str]] = None
     asset_contract_addresses: Optional[str] = None
-    token_ids: Optional[list[int]] = None
+    token_ids: Optional[list[str]] = None
     collection: Optional[str] = None
     owner: Optional[str] = None
     order_by: Optional[AssetsOrderBy] = None
@@ -136,5 +136,9 @@ def _validate_order_by(self) -> None:
             )
 
     def _validate_limit(self):
-        if not isinstance(self.client_params.limit, int) or not 0 <= self.client_params.limit <= 50:
+        if self.client_params.limit is None:
+            return
+        if not isinstance(self.client_params.limit, int):
+            raise TypeError("limit client param must be an int")
+        if not 0 <= self.client_params.limit <= 50:
             raise ValueError(f"limit param must be an int between 0 and 50.")

open_sea_v1/endpoints/client.py

@@ -10,10 +10,15 @@
 class ClientParams:
     """Common OpenSea Endpoint parameters to pass in."""
     offset: int = 0
-    limit: int = 20
+    page_size: int = 50
+    limit: Optional[int] = None
     max_pages: Optional[int] = None
     api_key: Optional[str] = None
 
+    def __post_init__(self):
+        if self.limit is not None and not 0 < int(self.limit) <= 300:
+            raise ValueError(f'{self.limit=} max value is 300.')
+
 
 class BaseClient(ABC):
     client_params: ClientParams
@@ -43,18 +48,16 @@ def get_pages(self) -> Generator[list[list[BaseResponse]], None, None]:
             self._http_response = self._get_request()
             if self.parsed_http_response:  # edge case
                 self.processed_pages += 1
-                self.client_params.offset += self.client_params.limit
+                self.client_params.offset += self.client_params.page_size
                 yield self.parsed_http_response
 
     def remaining_pages(self) -> bool:
         if self._http_response is None:
             return True
 
-        if all((
-                (max_pages_was_set := self.client_params.max_pages is not None),
-                (previous_page_was_not_empty := len(self.parsed_http_response) > 0),
-                (remaining_pages_until_max_pages := self.processed_pages <= self.client_params.max_pages),
-        )):
+        if (max_pages_was_set := self.client_params.max_pages is not None) and \
+            (previous_page_was_not_empty := len(self.parsed_http_response) > 0) and \
+                (remaining_pages_until_max_pages := self.processed_pages <= self.client_params.max_pages):
             return True
 
         if is_not_the_last_page := len(self.parsed_http_response) >= self.client_params.offset:

open_sea_v1/endpoints/events.py

@@ -68,7 +68,7 @@ class EventsEndpoint(BaseClient, BaseEndpoint):
     """
     client_params: ClientParams = None
     asset_contract_address: str = None
-    token_id: Optional[str] = None
+    token_id: Optional[int] = None
     collection_slug: Optional[str] = None
     account_address: Optional[str] = None
     occurred_before: Optional[datetime] = None
@@ -96,7 +96,7 @@ def _get_request(self, **kwargs) -> Response:
             account_address=self.account_address,
             auction_type=self.auction_type,
             occurred_before=self.occurred_before,
-            occurred_after=self.occurred_after
+            occurred_after=self.occurred_after,
         )
         get_request_kwargs = dict(params=params)
         self._http_response = super()._get_request(**get_request_kwargs)

open_sea_v1/endpoints/tests/test_client.py

@@ -11,18 +11,25 @@ class TestBaseEndpointClient(TestCase):
     def setUpClass(cls) -> None:
         cls.max_pages = 2
         cls.limit = 5
-        cls.sample_client = EventsEndpoint(
+        cls.sample_client_kwargs = dict(
             client_params=ClientParams(max_pages=cls.max_pages, limit=cls.limit),
             asset_contract_address="0x76be3b62873462d2142405439777e971754e8e77",
             token_id=str(10152),
             event_type=EventType.SUCCESSFUL,
         )
+        cls.sample_client = EventsEndpoint(**cls.sample_client_kwargs)
         cls.sample_pages = list(cls.sample_client.get_pages())
 
     def test_remaining_pages_true_if_http_response_is_none(self):
         self.sample_client._http_response = None
         self.assertTrue(self.sample_client.remaining_pages())
 
+    def test_remaining_pages_does_not_raise_if_client_params_all_none(self):
+        updated_kwargs = self.sample_client_kwargs | dict(client_params=ClientParams(max_pages=None, api_key=None))
+        client = EventsEndpoint(**updated_kwargs)
+        next(client.get_pages())
+        client.remaining_pages()  # assert not raises
+
     def test_get_pages_resets_processed_pages_and_offset_attr_on_new_calls(self):
         for _ in range(2):
             next(self.sample_client.get_pages())
@@ -52,3 +59,13 @@ def test_pagination_works(self):
         self.assertEqual(len(id_list_2), 12)  # updated limit * max_pages+1
         self.assertGreater(len(id_list_1), len(id_list_2))
         self.assertTrue(id_list_1[i] == id_list_2[i] for i in range(len(id_list_2)))
+
+    def test_pagination_does_not_return_duplicates_between_different_pages(self):
+        raise NotImplementedError
+        self.sample_client.client_params = ClientParams(limit=5, offset=0, max_pages=1)
+        page_1_event_ids = [e.event_id for e in self.sample_client.get_pages()]
+        self.sample_client.client_params = ClientParams(limit=5, offset=5, max_pages=1)
+        page_2_event_ids = self.sample_client.get_pages()
+        self.sample_client.client_params = ClientParams(limit=5, offset=10, max_pages=1)
+        page_3_event_ids = self.sample_client.get_pages()
+        ...

open_sea_v1/helpers/response_parser.py

@@ -26,7 +26,14 @@ def dump(self, to_parse: Optional[Union[OpenSeaResponse, list[OpenSeaResponse]]]
         with open(str(self.destination), 'w') as f:
             json.dump(the_jsons, f)
 
-    def load(self) -> Any:
+    def load(self, json_path: Optional[Path] = None) -> Any:
+        json_path = self.destination if not json_path else json_path
         with open(str(self.destination), 'r') as f:
             parsed_json = json.load(f)
         return [self.response_type(collection) for collection in parsed_json]
+
+    def load_from_dir(self) -> Any:
+        detected_json_files = (p for p in self.destination.iterdir() if '.json' in p.name and not p.is_dir())
+        resp = list()
+        for json_path in detected_json_files:
+            resp.append(self.load(destination=json_path))

open_sea_v1/responses/asset.py

@@ -2,6 +2,7 @@
 Assigns attributes to dictionnary values for easier object navigation.
 """
 from dataclasses import dataclass
+from typing import Optional
 
 from open_sea_v1.responses.abc import BaseResponse
 from open_sea_v1.responses.collection import CollectionResponse
@@ -77,8 +78,10 @@ def __post_init__(self):
 class AssetResponse(BaseResponse):
     _json: dict
 
-    def __str__(self) -> str:
-        return f"({AssetResponse.__name__}, id={self.token_id.zfill(5)}, name={self.name})"
+    def __str__(self):
+        id_str = f"token_id={self.token_id.zfill(5)}"
+        name = f"name={self.name}"
+        return "    ".join([id_str, name])
 
     def __post_init__(self):
         self._set_common_attrs()
@@ -123,17 +126,23 @@ def owner(self) -> _Owner:
         return _Owner(self._json['owner'])
 
     @property
-    def traits(self) -> list[_Traits]:
-        return [_Traits(traits) for traits in self._json['traits']]
+    def traits(self) -> Optional[list[_Traits]]:
+        traits = self._json.get('traits')
+        if traits:
+            return [_Traits(traits) for traits in self._json['traits']]
+        return None
 
     @property
-    def last_sale(self) -> _LastSale:
-        return _LastSale(self._json['last_sale'])
+    def last_sale(self) -> Optional[_LastSale]:
+        last_sale = self._json.get('last_sale')
+        if last_sale:
+            return _LastSale(self._json['last_sale'])
+        return None
 
     @property
     def collection(self):
         return CollectionResponse(self._json['collection'])
 
     @property
-    def creator(self) -> dict:
-        return self._json['creator']
+    def creator(self) -> Optional[dict]:
+        return self._json.get('creator')

open_sea_v1/responses/collection.py

@@ -2,6 +2,7 @@
 Assigns attributes to dictionnary values for easier object navigation.
 """
 from dataclasses import dataclass
+from typing import Optional
 
 from open_sea_v1.responses.abc import BaseResponse
 
@@ -11,7 +12,7 @@ class _CollectionStats:
     _json: dict
 
     def __str__(self) -> str:
-        return f"({_CollectionStats.__name__}, {self.floor_price=}, {self.average_price=}, {self.market_cap=})"
+        return f"{self.floor_price=}    {self.average_price=}   {self.market_cap=})"
 
     def __post_init__(self):
         self.one_day_volume = self._json["one_day_volume"]
@@ -42,9 +43,11 @@ class CollectionResponse(BaseResponse):
     _json: dict
 
     def __str__(self) -> str:
-        return f"({CollectionResponse.__name__}, {self.name=}, {self.short_description=})"
+        return f"{self.name=}   {self.short_description=})"
 
     def __post_init__(self):
+        self.primary_asset_contracts: Optional[list] = self._json.get('primary_asset_contracts')
+        self.traits: Optional[dict] = self._json.get('traits')
         self.banner_image_url = self._json["banner_image_url"]
         self.chat_url = self._json["chat_url"]
         self.created_date = self._json["created_date"]
@@ -77,5 +80,6 @@ def __post_init__(self):
         self.name = self._json["name"]
 
     @property
-    def stats(self) -> _CollectionStats:
-        return _CollectionStats(self._json['stats'])
+    def stats(self) -> Optional[_CollectionStats]:
+        stats = self._json.get('stats')
+        return _CollectionStats(stats) if stats else None

open_sea_v1/responses/event.py

@@ -1,21 +1,32 @@
 from dataclasses import dataclass
 
+from open_sea_v1.helpers.ether_converter import EtherConverter, EtherUnit
 from open_sea_v1.responses.asset import AssetResponse
 from open_sea_v1.responses.abc import BaseResponse
 
-
+import locale
 @dataclass
 class EventResponse(BaseResponse):
     _json: dict
 
     def __str__(self) -> str:
-        return f"{self.asset.name[:20]}, {self.transaction['timestamp'][:10]}, {self.quantity=}, {self.total_price=}"
+        locale.setlocale(locale.LC_ALL, '')  # big number str formater
+
+        name = self.asset.name[:20]
+        transaction_date = f"{self.transaction['timestamp'][:10]} {self.transaction['timestamp'][11:-3]}"
+        usd_price = round(self.usd_price / int(self.quantity), 2)
+        usd_price = f"{usd_price:,.2f}"
+        usd_price = f"{usd_price} USD"
+        eth_price = self.eth_price / int(self.quantity)
+        eth_price = f"{eth_price:.4f} ETH"  # trailing zeros
+
+        str_representation ="    ".join([name, transaction_date, usd_price, eth_price])
+        return str_representation
 
     def __post_init__(self):
         self.approved_account = self._json['approved_account']
         self.asset_bundle = self._json['asset_bundle']
         self.auction_type = self._json['auction_type']
-        # self.big_amount = self._json['big_amount']
         self.collection_slug = self._json['collection_slug']
         self.contract_address = self._json['contract_address']
         self.created_date = self._json['created_date']
@@ -33,6 +44,17 @@ def __post_init__(self):
         self.total_price = self._json['total_price']
         self.bid_amount = self._json['bid_amount']
 
+    @property
+    def eth_price(self):
+        eth_price = EtherConverter(quantity=self.total_price, unit=EtherUnit.WEI).ether
+        return eth_price
+
+    @property
+    def usd_price(self):
+        eth_to_usd_price = float(self.payment_token['usd_price'])  # 'eth_price' key also available
+        usd_price = round(self.eth_price * eth_to_usd_price, 2)
+        return usd_price
+
     @property
     def asset(self) -> AssetResponse:
         return AssetResponse(self._json['asset'])

open_sea_v1/responses/tests/test_reponse_event.py

@@ -14,6 +14,7 @@ class TestEventsObj(ResponseTestHelper):
     def setUpClass(cls) -> None:
         cls.events = cls.create_and_get(EventsEndpoint, **cls.events_default_kwargs)
         cls.event = cls.events[0]
+        event_name_str = str(cls.event)
 
     def test_attributes_do_not_raise_unexpected_exceptions(self):
         self.assert_attributes_do_not_raise_unexpected_exceptions(self.event)

open_sea_v1/responses/tests/test_response_asset.py

@@ -15,6 +15,7 @@ def setUpClass(cls) -> None:
         params = cls.default_asset_params | dict(token_ids=[1, 14, 33])
         cls.assets = cls.create_and_get(AssetsEndpoint, **params)
         cls.asset = cls.assets[0]
+        ...
 
     def test_attributes_do_not_raise_unexpected_exceptions(self):
         self.assert_attributes_do_not_raise_unexpected_exceptions(self.asset)