Ensure all fields are parsed (_base_parse). Use a factory method for creating subclass instance, based on the type field.

Formatting

Author: tehkillerbee

tidalapi/page.py

@@ -74,8 +74,10 @@ class Page:
     """
 
     title: str = ""
-    categories: Optional[List["AllCategories"]] = None
-    _categories_iter: Optional[Iterator["AllCategories"]] = None
+    categories: Optional[List[Union["AllCategories", "AllCategoriesV2"]]] = None
+    _categories_iter: Optional[Iterator[Union["AllCategories", "AllCategoriesV2"]]] = (
+        None
+    )
     _items_iter: Optional[Iterator[Callable[..., Any]]] = None
     page_category: "PageCategory"
     page_category_v2: "PageCategoryV2"
@@ -127,7 +129,7 @@ def parse(self, json_obj: JsonObj) -> "Page":
                 self.categories.append(page_item)
         else:
             for item in json_obj["items"]:
-                page_item = self.page_category_v2.parse(item)
+                page_item = self.page_category_v2.parse_item(item)
                 self.categories.append(page_item)
 
         return copy.copy(self)
@@ -158,10 +160,13 @@ class More:
     @classmethod
     def parse(cls, json_obj: JsonObj) -> Optional["More"]:
         show_more = json_obj.get("showMore")
-        if show_more is None:
-            return None
-        else:
+        view_all = json_obj.get("viewAll")
+        if show_more is not None:
             return cls(api_path=show_more["apiPath"], title=show_more["title"])
+        elif view_all is not None:
+            return cls(api_path=view_all, title=json_obj.get("title"))
+        else:
+            return None
 
 
 class PageCategory:
@@ -234,15 +239,34 @@ def show_more(self) -> Optional[Page]:
 
 
 class PageCategoryV2:
-    type = None
+    """Base class for all V2 homepage page categories (e.g., TRACK_LIST, SHORTCUT_LIST).
+
+    Handles shared fields and parsing logic, and automatically dispatches to the correct
+    subclass based on the 'type' field in the JSON object.
+    """
+
+    # Registry mapping 'type' strings to subclass types
+    _type_map: Dict[str, Type["PageCategoryV2"]] = {}
+
+    # Common metadata fields for all category types
+    type: Optional[str] = None
+    module_id: Optional[str] = None
     title: Optional[str] = None
+    subtitle: Optional[str] = None
     description: Optional[str] = ""
-    request: "Requests"
+    _more: Optional["More"] = None
 
     def __init__(self, session: "Session"):
+        """Store the shared session object and initialize common fields.
+
+        Subclasses should implement their own `parse()` method but not override
+        __init__.
+        """
         self.session = session
         self.request = session.request
-        self.item_type_parser: Dict[str, Callable[..., Any]] = {
+
+        # Common item parsers by type (can be used by subclasses like SimpleList)
+        self.item_types: Dict[str, Callable[..., Any]] = {
             "PLAYLIST": self.session.parse_playlist,
             "VIDEO": self.session.parse_video,
             "TRACK": self.session.parse_track,
@@ -251,59 +275,108 @@ def __init__(self, session: "Session"):
             "MIX": self.session.parse_v2_mix,
         }
 
-    def parse(self, json_obj: JsonObj) -> AllCategoriesV2:
-        category_type = json_obj["type"]
-        if category_type == "TRACK_LIST":
-            category = TrackList(self.session)
-        elif category_type == "SHORTCUT_LIST":
-            category = ShortcutList(self.session)
-        elif category_type == "HORIZONTAL_LIST":
-            category = HorizontalList(self.session)
-        elif category_type == "HORIZONTAL_LIST_WITH_CONTEXT":
-            category = HorizontalListWithContext(self.session)
-        else:
-            raise NotImplementedError(f"PageType {category_type} not implemented")
+    @classmethod
+    def register_subclass(cls, category_type: str):
+        """Decorator to register subclasses in the _type_map.
 
-        return category.parse(json_obj)
+        Usage:
+        @PageCategoryV2.register_subclass("TRACK_LIST")
+        class TrackList(PageCategoryV2):
+            ...
+        """
 
+        def decorator(subclass):
+            cls._type_map[category_type] = subclass
+            subclass.category_type = category_type
+            return subclass
+
+        return decorator
+
+    def parse_item(self, list_item: Dict) -> "PageCategoryV2":
+        """Factory method that creates the correct subclass instance based on the 'type'
+        field in item Dict, parses base fields, and then calls subclass parse()."""
+        category_type = list_item.get("type")
+        cls = self._type_map.get(category_type)
+        if cls is None:
+            raise NotImplementedError(f"Category {category_type} not implemented")
+        instance = cls(self.session)
+        instance._parse_base(list_item)
+        instance.parse(list_item)
+        return instance
+
+    def _parse_base(self, list_item: Dict):
+        """Parse fields common to all categories."""
+        self.type = list_item.get("type")
+        self.module_id = list_item.get("moduleId")
+        self.title = list_item.get("title")
+        self.subtitle = list_item.get("subtitle")
+        self.description = list_item.get("description")
+        self._more = More.parse(list_item)
+
+    def parse(self, json_obj: JsonObj):
+        """Subclasses implement this method to parse category-specific data."""
+        raise NotImplementedError("Subclasses must implement parse()")
+
+    def view_all(self) -> Optional[Page]:
+        """View all items in a Get the full list of items on their own :class:`.Page`
+        from a :class:`.PageCategory`
 
-class SimpleList(PageCategoryV2):
-    """A simple list of different items for the home page V2."""
+        :return: A :class:`.Page` more of the items in the category, None if there aren't any
+        """
+        api_path = self._more.api_path if self._more else None
+        return self.session.view_all(api_path) if api_path and self._more else None
 
-    items: Optional[List[Any]] = None
+
+class SimpleList(PageCategoryV2):
+    """A generic list of items (tracks, albums, playlists, etc.) using the shared
+    self.item_types parser dictionary."""
 
     def __init__(self, session: "Session"):
         super().__init__(session)
-        self.session = session
+        self.items: List[Any] = []
 
-    def parse(self, json_obj: JsonObj) -> "SimpleList":
-        self.items = []
-        self.title = json_obj["title"]
+    def parse(self, json_obj: "JsonObj"):
+        self.items = [self.get_item(item) for item in json_obj["items"]]
+        return self
 
-        for item in json_obj["items"]:
-            self.items.append(self.get_item(item))
+    def get_item(self, json_obj: "JsonObj") -> Any:
+        item_type = json_obj.get("type")
+        if item_type not in self.item_types:
+            raise NotImplementedError(f"Item type '{item_type}' not implemented")
 
-        return self
+        return self.item_types[item_type](json_obj["data"])
 
-    def get_item(self, json_obj):
-        item_type = json_obj["type"]
 
-        try:
-            if item_type in self.item_type_parser.keys():
-                return self.item_type_parser[item_type](json_obj["data"])
-            else:
-                raise NotImplementedError(f"PageItemType {item_type} not implemented")
-        except TypeError as e:
-            print(f"Exception {e} while parsing SimpleList object.")
+@PageCategoryV2.register_subclass("SHORTCUT_LIST")
+class ShortcutList(SimpleList):
+    """A list of "shortcut" links (typically small horizontally scrollable rows)."""
 
 
-class HorizontalList(SimpleList): ...
+@PageCategoryV2.register_subclass("HORIZONTAL_LIST")
+class HorizontalList(SimpleList):
+    """A horizontal scrollable row of items."""
 
 
-class HorizontalListWithContext(HorizontalList): ...
+@PageCategoryV2.register_subclass("HORIZONTAL_LIST_WITH_CONTEXT")
+class HorizontalListWithContext(HorizontalList):
+    """A horizontal list of items with additional context."""
 
 
-class ShortcutList(SimpleList): ...
+@PageCategoryV2.register_subclass("TRACK_LIST")
+class TrackList(PageCategoryV2):
+    """A category that represents a list of tracks, each one parsed with
+    parse_track()."""
+
+    def __init__(self, session: "Session"):
+        super().__init__(session)
+        self.items: List[Any] = []
+
+    def parse(self, json_obj: "JsonObj"):
+        self.items = [
+            self.session.parse_track(item["data"]) for item in json_obj["items"]
+        ]
+
+        return self
 
 
 class FeaturedItems(PageCategory):
@@ -384,27 +457,6 @@ def parse(self, json_obj: JsonObj) -> "ItemList":
         return copy.copy(self)
 
 
-class TrackList(PageCategory):
-    """A list of tracks from TIDAL."""
-
-    items: Optional[List[Any]] = None
-
-    def parse(self, json_obj: JsonObj) -> "TrackList":
-        """Parse a list of tracks on TIDAL from the pages endpoints.
-
-        :param json_obj: The json from TIDAL to be parsed
-        :return: A copy of the TrackList with a list of items
-        """
-        self.title = json_obj["title"]
-
-        self.items = []
-
-        for item in json_obj["items"]:
-            self.items.append(self.session.parse_track(item["data"]))
-
-        return copy.copy(self)
-
-
 class PageLink:
     """A Link to another :class:`.Page` on TIDAL, Call get() to retrieve the Page."""