Added support for new item filters

Author: Galarzaa90

CHANGELOG.rst

@@ -6,19 +6,28 @@ Changelog
     Due to this library relying on external content, older versions are not guaranteed to work.
     Try to always use the latest version.
 
+3.5.0 (2020-09-22)
+==================
+
+- Added support for the new filtering options added to current auctions:
+    - Added new enumeration: ``AuctionSearchType``
+    - Renamed ``AuctionFilters`` attribute ``item`` to ``search_string``.
+      Property alias kept for backwards compatibility.
+    - Added new attribute ``AuctionFilters.search_type``
+
 3.4.0 (2020-09-19)
-=================
+==================
 
 - Added option to only parse the listed information of an auction, to skip the rest of the parsing.
 - Fixed wrong type hint in ``ListedAuction`` for ``status``.
 
 3.3.0 (2020-09-09)
-=================
+==================
 
 - Added support for the Character Bazaar
     - Added classes: ``CharacterBazaar``, ``ListedAuction`` and ``AuctionDetails`` and many auxiliary classes.
 - Client methods throw a ``SiteMaintenanceError`` when Tibia.com is under maintenance, to be able to tell apart from
-other network errors.
+  other network errors.
 
 .. v3.2.2:
 

docs/api.rst

@@ -33,6 +33,10 @@ Enumerations are provided for various values in order to avoid depending on stri
     :members:
     :undoc-members:
 
+.. autoclass:: AuctionSearchType
+    :members:
+    :undoc-members:
+
 .. autoclass:: AuctionStatus
     :members:
     :undoc-members:

tests/resources/bazaar/tibiacom_current_all_filters.txt

@@ -2,7 +2,8 @@
 import unittest
 
 from tests.tests_tibiapy import TestCommons
-from tibiapy import AuctionDetails, AuctionOrder, AuctionOrderBy, AuctionStatus, BattlEyeTypeFilter, BidType, \
+from tibiapy import AuctionDetails, AuctionOrder, AuctionOrderBy, AuctionSearchType, AuctionStatus, BattlEyeTypeFilter, \
+    BidType, \
     CharacterBazaar, \
     InvalidContent, PvpTypeFilter, \
     Sex, SkillFilter, \
@@ -51,23 +52,16 @@ def test_character_bazaar_from_content_current_all_filters_selected(self):
 
         self.assertIsNotNone(bazaar)
         self.assertEqual(1, bazaar.page)
-        self.assertEqual(1, bazaar.total_pages)
-        self.assertEqual(9, bazaar.results_count)
-        self.assertEqual(9, len(bazaar.entries))
+        self.assertEqual(4, bazaar.total_pages)
+        self.assertEqual(92, bazaar.results_count)
+        self.assertEqual(25, len(bazaar.entries))
         self.assertIsNotNone(bazaar.url)
 
         auction = bazaar.entries[0]
-        self.assertEqual(36169, auction.auction_id)
-        self.assertEqual(2600, auction.bid)
+        self.assertEqual(82526, auction.auction_id)
+        self.assertEqual(57000, auction.bid)
         self.assertEqual(BidType.MINIMUM, auction.bid_type)
         self.assertIsNotNone(auction.character_url)
-        self.assertEqual(4, len(auction.displayed_items))
-
-        first_item = auction.displayed_items[0]
-        self.assertEqual(1, first_item.count)
-        self.assertEqual(9394, first_item.item_id)
-        self.assertEqual("claw of 'The Noxious Spawn'", first_item.name)
-        self.assertIsNotNone(first_item.image_url)
 
         self.assertIsNotNone(bazaar.filters)
         self.assertEqual('Antica', bazaar.filters.world)
@@ -78,10 +72,11 @@ def test_character_bazaar_from_content_current_all_filters_selected(self):
         self.assertEqual(1000, bazaar.filters.max_level)
         self.assertEqual(SkillFilter.MAGIC_LEVEL, bazaar.filters.skill)
         self.assertEqual(1, bazaar.filters.min_skill_level)
-        self.assertEqual(10, bazaar.filters.max_skill_level)
-        self.assertEqual(AuctionOrderBy.MAGIC_LEVEL, bazaar.filters.order_by)
+        self.assertEqual(50, bazaar.filters.max_skill_level)
+        self.assertEqual(AuctionOrderBy.SHIELDING, bazaar.filters.order_by)
         self.assertEqual(AuctionOrder.HIGHEST_LATEST, bazaar.filters.order)
-        self.assertEqual("destruction", bazaar.filters.item)
+        self.assertEqual("potion", bazaar.filters.item)
+        self.assertEqual(AuctionSearchType.ITEM_WILDCARD, bazaar.filters.search_type)
 
     def test_character_bazaar_from_content_empty(self):
         bazaar = CharacterBazaar.from_content(self.load_resource(FILE_BAZAAR_CURRENT_EMPTY))

tests/tests_bazaar.py

@@ -1,3 +1,6 @@
+__version__ = '3.5.0'
+__author__ = 'Allan Galarza'
+
 import logging
 
 from tibiapy import abc, enums, utils
@@ -17,8 +20,6 @@
 from tibiapy.bazaar import *
 from tibiapy.client import *
 
-__version__ = '3.4.0'
-
 from logging import NullHandler
 
 logging.getLogger(__name__).addHandler(NullHandler())

tibiapy/__init__.py

@@ -1,19 +1,20 @@
 import datetime
 import re
 import urllib.parse
-from abc import abstractmethod
-
-from typing import Dict, List, Optional, Type
+import warnings
+from typing import Dict, List, Optional
 
 import bs4
 
 from tibiapy import abc, InvalidContent, Sex, Vocation
 from tibiapy.abc import BaseCharacter
-from tibiapy.enums import AuctionOrder, AuctionOrderBy, AuctionStatus, BattlEyeTypeFilter, BazaarType, BidType, \
+from tibiapy.enums import AuctionOrder, AuctionOrderBy, AuctionSearchType, AuctionStatus, BattlEyeTypeFilter, \
+    BazaarType, BidType, \
     PvpTypeFilter, \
     SkillFilter, \
     VocationAuctionFilter
-from tibiapy.utils import convert_line_breaks, get_tibia_url, parse_integer, parse_pagination, parse_tibia_datetime, \
+from tibiapy.utils import convert_line_breaks, deprecated, get_tibia_url, parse_integer, parse_pagination, \
+    parse_tibia_datetime, \
     parse_tibia_money, \
     parse_tibiacom_content, \
     try_enum
@@ -95,6 +96,10 @@ class AuctionFilters(abc.Serializable):
         The minimum skill level of the selected :attr:`skill` to display.
     max_skill_level: :class:`int`
         The maximum skill level of the selected :attr:`skill` to display.
+    search_string: :class:`str`
+        The search term to filter out auctions.
+    search_type: :class:`AuctionSearchType`
+        The type of search to use. Defines the behaviour of :py:attr:`search_string`.
     """
     __slots__ = (
         "world",
@@ -108,7 +113,8 @@ class AuctionFilters(abc.Serializable):
         "max_skill_level",
         "order_by",
         "order",
-        "item",
+        "search_string",
+        "search_type",
     )
 
     def __init__(self, **kwargs):
@@ -123,7 +129,8 @@ def __init__(self, **kwargs):
         self.max_skill_level: Optional[int] = kwargs.get("max_skill_level")
         self.order_by: Optional[AuctionOrderBy] = kwargs.get("order_by")
         self.order: Optional[AuctionOrder] = kwargs.get("order")
-        self.item: Optional[str] = kwargs.get("item")
+        self.search_string: Optional[str] = kwargs.get("search_string")
+        self.search_type: Optional[AuctionSearchType] = kwargs.get("search_type")
 
     def __repr__(self):
         attributes = ""
@@ -132,6 +139,21 @@ def __repr__(self):
             attributes += " %s=%r" % (attr, v)
         return "<{0.__class__.__name__}{1}>".format(self, attributes)
 
+    @property
+    def item(self):
+        """:class:`str`: The name of the item to search for.
+
+        .. deprecated:: 3.5.0
+            Use :py:attr:`search_string` instead.
+        """
+        warnings.warn("Deprecated, use 'search_string'instead", DeprecationWarning)
+        return self.search_string
+
+    @item.setter
+    @deprecated(instead="search_string")
+    def item(self, value):
+        self.search_string = value
+
     @property
     def query_params(self):
         """:class:`str`: The query parameters representing this filter."""
@@ -147,7 +169,8 @@ def query_params(self):
             "filter_skillrangeto": self.max_skill_level,
             "order_column": self.order_by.value if self.order_by else None,
             "order_direction": self.order.value if self.order else None,
-            "itemname": self.item,
+            "searchstring": self.search_string,
+            "searchtype": self.search_type.value if self.search_type else None,
         }
         return {k: v for k, v in params.items() if v}
 
@@ -167,30 +190,22 @@ def _parse_filter_table(cls, table):
         filters = AuctionFilters()
         world_select = table.find("select", {"name": "filter_world"})
         selected_world_option = world_select.find("option", {"selected": True})
-        if selected_world_option is None or not selected_world_option["value"]:
-            filters.world = None
-        else:
+        if selected_world_option is not None and selected_world_option["value"]:
             filters.world = selected_world_option["value"]
 
         pvp_select = table.find("select", {"name": "filter_worldpvptype"})
         selected_pvp_option = pvp_select.find("option", {"selected": True})
-        if selected_pvp_option is None or not selected_pvp_option["value"]:
-            filters.pvp_type = None
-        else:
+        if selected_pvp_option is not None and selected_pvp_option["value"]:
             filters.pvp_type = try_enum(PvpTypeFilter, parse_integer(selected_pvp_option["value"], None))
 
         battleye_select = table.find("select", {"name": "filter_worldbattleyestate"})
         selected_battleye_option = battleye_select.find("option", {"selected": True})
-        if selected_battleye_option is None or not selected_battleye_option["value"]:
-            filters.battleye = None
-        else:
+        if selected_battleye_option is not None and selected_battleye_option["value"]:
             filters.battleye = try_enum(BattlEyeTypeFilter, parse_integer(selected_battleye_option["value"], None))
 
         vocation_select = table.find("select", {"name": "filter_profession"})
         selected_vocation_option = vocation_select.find("option", {"selected": True})
-        if selected_vocation_option is None or not selected_vocation_option["value"]:
-            filters.vocation = None
-        else:
+        if selected_vocation_option is not None and selected_vocation_option["value"]:
             filters.vocation = try_enum(VocationAuctionFilter, parse_integer(selected_vocation_option["value"], None))
 
         minlevel_input = table.find("input", {"name": "filter_levelrangefrom"})
@@ -200,9 +215,7 @@ def _parse_filter_table(cls, table):
 
         skill_select = table.find("select", {"name": "filter_skillid"})
         selected_skill_option = skill_select.find("option", {"selected": True})
-        if selected_skill_option is None or not selected_skill_option["value"]:
-            filters.skill = None
-        else:
+        if selected_skill_option is not None and selected_skill_option["value"]:
             filters.skill = try_enum(SkillFilter, parse_integer(selected_skill_option["value"], None))
         min_skill_level_input = table.find("input", {"name": "filter_skillrangefrom"})
         max_skill_level_input = table.find("input", {"name": "filter_skillrangeto"})
@@ -211,20 +224,23 @@ def _parse_filter_table(cls, table):
 
         order_by_select = table.find("select", {"name": "order_column"})
         selected_order_by_option = order_by_select.find("option", {"selected": True})
-        if selected_order_by_option is None or not selected_order_by_option["value"]:
-            filters.order_by = None
-        else:
+        if selected_order_by_option is not None and selected_order_by_option["value"]:
             filters.order_by = try_enum(AuctionOrderBy, parse_integer(selected_order_by_option["value"], None))
 
         order_select = table.find("select", {"name": "order_direction"})
         selected_order_option = order_select.find("option", {"selected": True})
-        if selected_order_option is None or not selected_order_option["value"]:
-            filters.order = None
-        else:
+        if selected_order_option is not None and selected_order_option["value"]:
             filters.order = try_enum(AuctionOrder, parse_integer(selected_order_option["value"], None))
 
-        name_input = table.find("input", {"name": "itemname"})
-        filters.item = name_input["value"] or None
+        search_string_input = table.find("input", {"name": "searchstring"})
+        if search_string_input is not None and search_string_input["value"]:
+            filters.search_string = search_string_input["value"] or None
+
+        search_type_input = table.find("input", {"name": "searchtype", "checked": "checked"})
+
+        if search_type_input is not None and search_type_input["value"]:
+            filters.search_type = try_enum(AuctionSearchType, parse_integer(search_type_input["value"], None))
+
         return filters
 
 

tibiapy/bazaar.py

@@ -5,6 +5,7 @@
     'AuctionOrder',
     'AuctionOrderBy',
     'AuctionStatus',
+    'AuctionSearchType',
     'Category',
     'BattlEyeTypeFilter',
     'BazaarType',
@@ -78,6 +79,16 @@ class AuctionOrderBy(NumericEnum):
     SWORD_FIGHTING = 8
 
 
+class AuctionSearchType(NumericEnum):
+    """The possible search types."""
+    ITEM_DEFAULT  = 0
+    """Searches everything that includes the words on the search string."""
+    ITEM_WILDCARD = 1
+    """Searches everything that includes the search string"""
+    CHARACTER_NAME = 2
+    """Searches a character's name."""
+
+
 class AuctionStatus(BaseEnum):
     """The possible values an auction might have."""
     IN_PROGRESS = 'in progress'