fix: fixed profile pages after blizzard unlocks update (#297)

* fix: fixed profile pages after blizzard unlocks update

* fixes after review

* fix: updated volumes

Author: TeKrop

app/cache_manager.py

@@ -122,20 +122,6 @@ def update_player_cache(self, player_id: str, value: dict) -> None:
             ex=settings.player_cache_timeout,
         )
 
-    @valkey_connection_handler
-    def get_unlock_data_cache(self, cache_key: str) -> str | None:
-        data_cache = self.valkey_server.hget(settings.unlock_data_cache_key, cache_key)
-        return data_cache.decode("utf-8") if data_cache else None
-
-    @valkey_connection_handler
-    def update_unlock_data_cache(self, unlock_data: dict[str, str]) -> None:
-        for data_key, data_value in unlock_data.items():
-            self.valkey_server.hset(
-                settings.unlock_data_cache_key,
-                data_key,
-                data_value,
-            )
-
     @valkey_connection_handler
     def is_being_rate_limited(self) -> bool:
         return self.valkey_server.exists(settings.blizzard_rate_limit_key)

app/config.py

@@ -122,22 +122,6 @@ class Settings(BaseSettings):
     # Cache TTL for hero stats data (seconds)
     hero_stats_cache_timeout: int = 3600
 
-    ############
-    # UNLOCKS DATA (AVATARS, NAMECARDS, TITLES)
-    ############
-
-    # Cache key for unlock data cache in Valkey.
-    unlock_data_cache_key: str = "unlock-data-cache"
-
-    # URI of the page where unlock data can be retrieved
-    unlock_data_path: str = "/search/unlocks/"
-
-    # Batch size to use when requesting unlock data
-    unlock_data_batch_size: int = 50
-
-    # Keys that should be retrieved for unlocks
-    unlock_keys: set[str] = {"portrait", "namecard", "title"}
-
     ############
     # BLIZZARD
     ############

app/helpers.py

@@ -1,6 +1,7 @@
 """Parser Helpers module"""
 
 import csv
+import traceback
 from functools import cache
 from pathlib import Path
 
@@ -65,9 +66,10 @@ def overfast_internal_error(url: str, error: Exception) -> HTTPException:
 
     # Log the critical error
     logger.critical(
-        "Internal server error for URL {} : {}",
+        "Internal server error for URL {} : {}\n{}",
         url,
         str(error),
+        traceback.format_stack(),
     )
 
     # If we're using a profiler, it means we're debugging, raise the error

app/players/enums.py

@@ -88,18 +88,6 @@ class CompetitiveDivision(StrEnum):
     ULTIMATE = "ultimate"
 
 
-class UnlockDataType(StrEnum):
-    NAMECARD = "namecard"
-    PORTRAIT = "portrait"
-    TITLE = "title"
-
-    # Special value to only retrieve last_updated_at value
-    LAST_UPDATED_AT = "lastUpdatedAt"
-
-    # Special value to retrieve all the player data from search endpoint
-    SUMMARY = "summary"
-
-
 class PlayerRegion(StrEnum):
     EUROPE = "europe"
     AMERICAS = "americas"

app/players/helpers.py

@@ -32,12 +32,11 @@ def key_to_label(key: str) -> str:
     return " ".join(s.capitalize() for s in key.split("_"))
 
 
-@cache
-def get_player_title(title: str | None) -> str | None:
-    """Get player title from string extracted from Blizzard page. This is
-    where we're handling the special "no title" case for which we return None
+def get_player_title(title: dict | str) -> str | None:
+    """Get player title from string or dict extracted from Blizzard API.
+    This is where we're handling the special "empty string" case for which we return None
     """
-    return None if title and title.lower() == "no title" else title
+    return title["en_US"] if title else None
 
 
 def get_computed_stat_value(input_str: str) -> str | float | int:

app/players/models.py

@@ -78,6 +78,12 @@ class PlayerShort(BaseModel):
         ),
         examples=[1704209332],
     )
+    is_public: bool | None = Field(
+        None,
+        title="Is public",
+        description="Whether or not the player profile is public",
+        examples=[True],
+    )
 
 
 class PlayerSearchResult(BaseModel):

app/players/parsers/base_player_parser.py

@@ -66,7 +66,7 @@ async def parse(self) -> None:
 
     async def __retrieve_player_summary_data(self) -> dict | None:
         """Call Blizzard search page with user name to
-        check last_updated_at and retrieve unlock values
+        check last_updated_at and retrieve summary values
         """
         player_summary_parser = SearchDataParser(player_id=self.player_id)
         await player_summary_parser.parse()

app/players/parsers/player_career_parser.py

@@ -163,30 +163,14 @@ def __get_summary(self) -> dict:
 
         return {
             "username": summary_div.css_first("h1.Profile-player--name").text(),
-            "avatar": (
-                summary_div.css_first("img.Profile-player--portrait").attributes.get(
-                    "src"
-                )
-            ),
-            "namecard": self.player_data["summary"]["namecard"],
-            "title": self.__get_title(profile_div),
+            "avatar": self.player_data["summary"]["avatar"],
+            "namecard": self.player_data["summary"].get("namecard"),
+            "title": get_player_title(self.player_data["summary"]["title"]),
             "endorsement": self.__get_endorsement(progression_div),
             "competitive": self.__get_competitive_ranks(progression_div),
             "last_updated_at": self.player_data["summary"]["lastUpdated"],
         }
 
-    @staticmethod
-    def __get_title(profile_div: LexborNode) -> str | None:
-        # We return None is there isn't any player title div
-        if not (title_tag := profile_div.css_first("h2.Profile-player--title")):
-            return None
-
-        # Retrieve the title text
-        title = title_tag.text() or None
-
-        # Special case : the "no title" means there is no title
-        return get_player_title(title)
-
     @staticmethod
     def __get_endorsement(progression_div: LexborNode) -> dict | None:
         endorsement_span = progression_div.css_first(

app/players/parsers/player_search_parser.py

@@ -5,7 +5,6 @@
 from app.config import settings
 from app.overfast_logger import logger
 from app.parsers import JSONParser
-from app.unlocks_manager import UnlocksManager
 
 from ..helpers import get_player_title
 
@@ -21,7 +20,6 @@ def __init__(self, **kwargs):
         self.order_by = kwargs.get("order_by")
         self.offset = kwargs.get("offset")
         self.limit = kwargs.get("limit")
-        self.unlocks_manager = UnlocksManager()
 
     def get_blizzard_url(self, **kwargs) -> str:
         """URL used when requesting data to Blizzard."""
@@ -34,7 +32,7 @@ async def parse_data(self) -> dict:
 
         # Transform into PlayerSearchResult format
         logger.info("Applying transformation..")
-        players = await self.apply_transformations(players)
+        players = self.apply_transformations(players)
 
         # Apply ordering
         logger.info("Applying ordering..")
@@ -58,31 +56,26 @@ def filter_players(self) -> list[dict]:
         battletag = self.search_nickname.replace("-", "#")
         return [player for player in self.json_data if player["battleTag"] == battletag]
 
-    async def apply_transformations(self, players: Iterable[dict]) -> list[dict]:
+    def apply_transformations(self, players: Iterable[dict]) -> list[dict]:
         """Apply transformations to found players in order to return the data
         in the OverFast API format. We'll also retrieve some data from parsers.
         """
         transformed_players = []
 
-        # Retrieve and cache Unlock IDs
-        unlock_ids = self.__retrieve_unlock_ids(players)
-        await self.unlocks_manager.cache_values(unlock_ids)
-
         for player in players:
             player_id = player["battleTag"].replace("#", "-")
 
             transformed_players.append(
                 {
                     "player_id": player_id,
                     "name": player["battleTag"],
-                    "avatar": self.unlocks_manager.get(player["portrait"]),
-                    "namecard": self.unlocks_manager.get(player["namecard"]),
-                    "title": get_player_title(
-                        self.unlocks_manager.get(player["title"])
-                    ),
+                    "avatar": player["avatar"],
+                    "namecard": player.get("namecard"),
+                    "title": get_player_title(player["title"]),
                     "career_url": f"{settings.app_base_url}/players/{player_id}",
                     "blizzard_id": player["url"],
                     "last_updated_at": player["lastUpdated"],
+                    "is_public": player["isPublic"],
                 },
             )
         return transformed_players
@@ -95,6 +88,3 @@ def apply_ordering(self, players: list[dict]) -> list[dict]:
             reverse=order_arrangement == "desc",
         )
         return players
-
-    def __retrieve_unlock_ids(self, players: list[dict]) -> set[str]:
-        return {player[key] for player in players for key in settings.unlock_keys}

app/players/parsers/search_data_parser.py

@@ -3,7 +3,6 @@
 from app.config import settings
 from app.overfast_logger import logger
 from app.parsers import JSONParser
-from app.unlocks_manager import UnlocksManager
 
 
 class SearchDataParser(JSONParser):
@@ -14,7 +13,6 @@ class SearchDataParser(JSONParser):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.player_id = kwargs.get("player_id")
-        self.unlocks_manager = UnlocksManager()
 
     async def parse_data(self) -> dict:
         # We'll use the battletag for searching
@@ -25,7 +23,10 @@ async def parse_data(self) -> dict:
             player_data = next(
                 player
                 for player in self.json_data
-                if player["battleTag"] == player_battletag
+                if (
+                    player["battleTag"] == player_battletag
+                    and player["isPublic"] is True
+                )
             )
         except StopIteration:
             # We didn't find the player, return nothing
@@ -35,32 +36,9 @@ async def parse_data(self) -> dict:
             )
             return {}
 
-        # Once we found the player, add unlock values in data (avatar, namecard, title)
-        return await self._enrich_with_unlock_values(player_data)
+        return player_data
 
     def get_blizzard_url(self, **kwargs) -> str:
         # Replace dash by encoded number sign (#) for search
         player_name = kwargs.get("player_id").split("-", 1)[0]
         return f"{super().get_blizzard_url(**kwargs)}/{player_name}/"
-
-    async def _enrich_with_unlock_values(self, player_data: dict) -> dict:
-        """Enrich player data with unlock values"""
-
-        # First cache unlock data if not already done
-        unlock_ids = {
-            player_data[key]
-            for key in settings.unlock_keys
-            if player_data[key] is not None
-        }
-
-        await self.unlocks_manager.cache_values(unlock_ids)
-
-        # Then return values with existing unlock keys replaced by their respective values
-        return {
-            key: (
-                self.unlocks_manager.get(value)
-                if key in settings.unlock_keys
-                else value
-            )
-            for key, value in player_data.items()
-        }