Restructures project to work with /discover page

Bandcamp removed the "Discover" section from their main page
since we wrote this code. Now, the tracks are only available at the
dedicated /discover URL.

I restructured the code to target the /discover site instead, which
required a couple of changes. Still, the existing POM structure was
helpful :)

I also (re)introduced a new "pause" option, because that's a bit easier
in this new structure.

Finally, I only allow loading more songs once, which gives a total of
120 songs to pick from with the default screen setting. Attempting to
load more resulted in errors, I think because they'd be outside of the
viewport and I didn't want to expand the code more and introduce
scrolling more of them into view. Also, not sure whether that'd take
earlier ones out of the viewport (etc) so I just decided not to open
that can of worms for this "Intro to Selenium" tutorial. LMK if you
disagree, otherwise of course you can tackle that in your longer one
that builds on top of this one :)

Author: martin-martin

python-selenium/pyproject.toml

@@ -16,3 +16,6 @@ dependencies = [
 ]
 [project.scripts]
 bandcamp-player = "bandcamp.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

python-selenium/requirements.txt

@@ -1,15 +1,15 @@
-attrs==24.2.0
-certifi==2024.8.30
+attrs==25.2.0
+certifi==2025.1.31
 h11==0.14.0
 idna==3.10
 outcome==1.3.0.post0
-PySocks==1.7.1
-selenium==4.25.0
+pysocks==1.7.1
+selenium==4.29.0
 sniffio==1.3.1
 sortedcontainers==2.4.0
-trio==0.27.0
-trio-websocket==0.11.1
-typing_extensions==4.12.2
-urllib3==2.2.3
+trio==0.29.0
+trio-websocket==0.12.2
+typing-extensions==4.12.2
+urllib3==2.3.0
 websocket-client==1.8.0
 wsproto==1.2.0

python-selenium/src/bandcamp/__main__.py

@@ -1,6 +1,11 @@
-from bandcamp.app.tui import interact
+from bandcamp.app.tui import TUI
 
 
 def main():
-    """Provide the main entry point for the app."""
-    interact()
+    """Provides the main entry point for the app."""
+    tui = TUI()
+    tui.interact()
+
+
+if __name__ == "__main__":
+    main()

python-selenium/src/bandcamp/app/player.py

@@ -2,44 +2,46 @@
 from selenium.webdriver.firefox.options import Options
 
 from bandcamp.web.element import TrackElement
-from bandcamp.web.page import HomePage
+from bandcamp.web.page import DiscoverPage
 
-BANDCAMP_FRONTPAGE_URL = "https://bandcamp.com/"
+BANDCAMP_DISCOVER = "https://bandcamp.com/discover/"
 
 
 class Player:
-    """Play tracks from Bandcamp's Discover section."""
+    """Plays tracks from Bandcamp's Discover page."""
 
     def __init__(self) -> None:
         self._driver = self._set_up_driver()
-        self.home = HomePage(self._driver)
-        self.discover = self.home.discover_tracklist
+        self.page = DiscoverPage(self._driver)
+        self.tracklist = self.page.discover_tracklist
         self._current_track = TrackElement(
-            self.home.discover_tracklist.available_tracks[0], self._driver
+            self.tracklist.available_tracks[0], self._driver
         )
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb):
-        """Close the headless browser."""
-        self._driver.close()
+        """Closes the headless browser."""
+        self._driver.quit()
 
     def play(self, track_number=None):
-        """Play the first track, or one of the available numbered tracks."""
+        """Plays the first track, or one of the available numbered tracks."""
         if track_number:
             self._current_track = TrackElement(
-                self.home.discover_tracklist.available_tracks[
-                    track_number - 1
-                ],
+                self.tracklist.available_tracks[track_number - 1],
                 self._driver,
             )
         self._current_track.play()
 
+    def pause(self):
+        """Pauses the current track."""
+        self._current_track.pause()
+
     def _set_up_driver(self):
-        """Create a headless browser pointing to Bandcamp."""
+        """Creates a headless browser pointing to Bandcamp."""
         options = Options()
         options.add_argument("--headless")
         browser = Firefox(options=options)
-        browser.get(BANDCAMP_FRONTPAGE_URL)
+        browser.get(BANDCAMP_DISCOVER)
         return browser

python-selenium/src/bandcamp/app/tui.py

@@ -1,61 +1,76 @@
-"""Provide a text-based user interface for a Bandcamp music player."""
-
 from bandcamp.app.player import Player
 
-COLUMN_WIDTH = CW = 30
 
+class TUI:
+    """Provides a text-based user interface for a Bandcamp music player."""
+
+    COLUMN_WIDTH = CW = 30
+    MAX_TRACKS = 120  # Twice the number of tracks that fit in the viewport.
+
+    def interact(self):
+        """Controls the player through user interactions."""
+        with Player() as player:
+            while True:
+                print(
+                    "\nType: [play <track number>], [pause], [tracks], [more], [exit]"
+                )
+                command = input("> ").strip().lower()
 
-def interact():
-    """Control the player through user interactions."""
-    with Player() as player:
-        while True:
-            print("\nType: play [<track_number>] | tracks | more | exit")
-            match input("> ").strip().lower().split():
-                case ["play"]:
-                    play(player)
-                case ["play", track]:
+                if command.startswith("play"):
                     try:
-                        track_number = int(track)
-                        play(player, track_number)
+                        track_number = int(command.split()[1])
+                        self.play(player, track_number)
+                    except IndexError:  # Play first track.
+                        self.play(player)
                     except ValueError:
                         print("Please provide a valid track number.")
-                case ["tracks"]:
-                    display_tracks(player)
-                case ["more"]:
-                    player.discover.load_more()
-                    display_tracks(player)
-                case ["exit"]:
+                elif command == "pause":
+                    self.pause(player)
+                elif command == "tracks":
+                    self.tracks(player)
+                elif command == "more":
+                    # A higher number of tracks can't be clicked without scrolling.
+                    if len(player.tracklist.available_tracks) >= self.MAX_TRACKS:
+                        print("Can't load more tracks. Pick one from the track list.")
+                    else:
+                        player.tracklist.load_more()
+                        self.tracks(player)
+                elif command == "exit":
                     print("Exiting the player...")
                     break
-                case _:
+                else:
                     print("Unknown command. Try again.")
 
+    def play(self, player, track_number=None):
+        """Plays a track and shows info about the track."""
+        player.play(track_number)
+        print(player._current_track._get_track_info())
 
-def play(player, track_number=None):
-    """Play a track and show info about the track."""
-    player.play(track_number)
-    print(player._current_track._get_track_info())
-
-
-def display_tracks(player):
-    """Display information about the currently playable tracks."""
-    header = (
-        f"{'#':<5} {'Album':<{CW}} " f"{'Artist':<{CW}} " f"{'Genre':<{CW}}"
-    )
-    print(header)
-    print("-" * 100)
-    for track_number, track in enumerate(
-        player.discover.available_tracks, start=1
-    ):
-        album, artist, *genre = track.text.split("\n")
-        album = _truncate(album, CW)
-        artist = _truncate(artist, CW)
-        genre = _truncate(genre[0], CW) if genre else ""
-        print(
-            f"{track_number:<5} {album:<{CW}} " f"{artist:<{CW}} {genre:<{CW}}"
-        )
+    def pause(self, player):
+        """Pauses the current track."""
+        player.pause()
 
+    def tracks(self, player):
+        """Displays information about the currently playable tracks."""
+        header = (
+            f"{'#':<5} {'Album':<{self.CW}} {'Artist':<{self.CW}} {'Genre':<{self.CW}}"
+        )
+        print(header)
+        print("-" * 100)
+        for track_number, track in enumerate(
+            player.tracklist.available_tracks, start=1
+        ):
+            if track.text:
+                album, artist, *genre = track.text.split("\n")
+                album = self._truncate(album, self.CW)
+                artist = self._truncate(artist, self.CW)
+                genre = self._truncate(genre[0], self.CW) if genre else ""
+                print(
+                    f"{track_number:<5} {album:<{self.CW}} "
+                    f"{artist:<{self.CW}} {genre:<{self.CW}}"
+                )
 
-def _truncate(text, width):
-    """Truncate track information."""
-    return text[: width - 3] + "..." if len(text) > width else text
+    @staticmethod
+    def _truncate(text, width):
+        """Truncates track information."""
+        return text[: width - 3] + "..." if len(text) > width else text

python-selenium/src/bandcamp/web/base.py

@@ -5,6 +5,7 @@
 from selenium.webdriver.support.wait import WebDriverWait
 
 MAX_WAIT_SECONDS = 10.0
+DEFAULT_WINDOW_SIZE = (1920, 3000)  # Shows 60 tracks
 
 
 @dataclass
@@ -18,6 +19,7 @@ class Track:
 class WebPage:
     def __init__(self, driver: WebDriver) -> None:
         self._driver = driver
+        self._driver.set_window_size(*DEFAULT_WINDOW_SIZE)
         self._wait = WebDriverWait(driver, MAX_WAIT_SECONDS)
 
 

python-selenium/src/bandcamp/web/element.py

@@ -1,55 +1,82 @@
+from selenium.common.exceptions import NoSuchElementException
 from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support import expected_conditions as EC
 
 from bandcamp.web.base import Track, WebComponent
-from bandcamp.web.locators import HomePageLocator, TrackLocator
+from bandcamp.web.locators import DiscoverPageLocatorMixin, TrackLocatorMixin
 
 
-class TrackElement(WebComponent, TrackLocator):
-    """Model a playable track in Bandcamp's Discover section."""
+class TrackElement(WebComponent, TrackLocatorMixin):
+    """Models a playable track in Bandcamp's Discover section."""
 
     def play(self) -> None:
-        """Play the track."""
-        if not self.is_playing():
+        """Plays the track."""
+        if not self.is_playing:
             self._get_play_button().click()
-            self._wait.until(lambda _: self.is_playing())
 
+    def pause(self) -> None:
+        """Pauses the track."""
+        if self.is_playing:
+            self._get_play_button().click()
+
+    @property
     def is_playing(self) -> bool:
-        return "playing" in self._get_play_button().get_attribute("class")
+        return "Pause" in self._get_play_button().get_attribute("aria-label")
 
     def _get_track_info(self) -> Track:
-        """Create a representation of the track's relevant information."""
-        full_url = self._parent.find_element(*self.ALBUM).get_attribute("href")
+        """Creates a representation of the track's relevant information."""
+        full_url = self._parent.find_element(*self.URL).get_attribute("href")
         # Cut off the referrer query parameter
         clean_url = full_url.split("?")[0] if full_url else ""
+        # Some tracks don't have a genre
+        try:
+            genre = self._parent.find_element(*self.GENRE).text
+        except NoSuchElementException:
+            genre = ""
         return Track(
             album=self._parent.find_element(*self.ALBUM).text,
             artist=self._parent.find_element(*self.ARTIST).text,
-            genre=self._parent.find_element(*self.GENRE).text,
+            genre=genre,
             url=clean_url,
         )
 
     def _get_play_button(self):
         return self._parent.find_element(*self.PLAY_BUTTON)
 
 
-class DiscoverTrackList(WebComponent, HomePageLocator):
-    """Model the track list in Bandcamp's Discover section."""
+class DiscoverTrackList(WebComponent, DiscoverPageLocatorMixin, TrackLocatorMixin):
+    """Models the track list in Bandcamp's Discover section."""
 
     def __init__(self, parent: WebElement, driver: WebDriver = None) -> None:
         super().__init__(parent, driver)
         self.available_tracks = self._get_available_tracks()
 
     def load_more(self) -> None:
-        """Load additional tracks in the Discover section."""
-        self._get_next_page_button().click()
+        """Loads additional tracks in the Discover section."""
+        view_more_button = self._driver.find_element(*self.PAGINATION_BUTTON)
+        view_more_button.click()
+        # The button is disabled until all new tracks are loaded.
+        self._wait.until(EC.element_to_be_clickable(self.PAGINATION_BUTTON))
         self.available_tracks = self._get_available_tracks()
 
     def _get_available_tracks(self) -> list:
-        """Find all currently available tracks in the Discover section."""
-        all_tracks = self._driver.find_elements(*self.TRACK)
-        return [track for track in all_tracks if track.is_displayed()]
+        """Finds all currently available tracks in the Discover section."""
+        self._wait.until(
+            lambda driver: any(
+                e.is_displayed() and e.text.strip()
+                for e in driver.find_elements(*self.ITEM)
+            ),
+            message="Timeout waiting for track text to load",
+        )
+
+        all_items = self._driver.find_elements(*self.ITEM)
+        all_tracks = []
+        for item in all_items:
+            if item.find_element(*self.PLAY_BUTTON):
+                all_tracks.append(item)
 
-    def _get_next_page_button(self):
-        """Locate and return the 'Next' button that loads more results."""
-        return self._driver.find_elements(*self.PAGINATION_BUTTON)[-1]
+        # Filter tracks that are displayed and have text.
+        return [
+            track for track in all_tracks if track.is_displayed() and track.text.strip()
+        ]

python-selenium/src/bandcamp/web/locators.py

@@ -1,14 +1,19 @@
 from selenium.webdriver.common.by import By
 
 
-class HomePageLocator:
-    DISCOVER_RESULTS = (By.CLASS_NAME, "discover-results")
-    TRACK = (By.CLASS_NAME, "discover-item")
-    PAGINATION_BUTTON = (By.CLASS_NAME, "item-page")
+class DiscoverPageLocatorMixin:
+    DISCOVER_RESULTS = (By.CLASS_NAME, "results-grid")
+    ITEM = (By.CLASS_NAME, "results-grid-item")
+    PAGINATION_BUTTON = (By.ID, "view-more")
+    COOKIE_ACCEPT_NECESSARY = (
+        By.CSS_SELECTOR,
+        "#cookie-control-dialog button.g-button.outline",
+    )
 
 
-class TrackLocator:
-    PLAY_BUTTON = (By.CSS_SELECTOR, "a")
-    ALBUM = (By.CLASS_NAME, "item-title")
-    GENRE = (By.CLASS_NAME, "item-genre")
-    ARTIST = (By.CLASS_NAME, "item-artist")
+class TrackLocatorMixin:
+    PLAY_BUTTON = (By.CSS_SELECTOR, "button.play-pause-button")
+    URL = (By.CSS_SELECTOR, "div.meta p a")
+    ALBUM = (By.CSS_SELECTOR, "div.meta p a strong")
+    GENRE = (By.CSS_SELECTOR, "div.meta p.genre")
+    ARTIST = (By.CSS_SELECTOR, "div.meta p a span")