Apply Technical Review suggestions

Co-authored-by: Bartosz <[email protected]>

Author: martin-martin

python-selenium/README.md

@@ -12,21 +12,23 @@ Then, install the requirements:
 (venv) $ python -m pip install -r requirements.txt
 ```
 
-The only direct dependency for this project is [Selenium](https://selenium-python.readthedocs.io/). You should use a Python version of at least 3.8.
+The only direct dependency for this project is [Selenium](https://selenium-python.readthedocs.io/). You should use a Python version of at least 3.10, which is necessary to support [structural pattern matching](https://realpython.com/structural-pattern-matching/).
+
+You'll need a [Firefox Selenium driver](https://selenium-python.readthedocs.io/installation.html#drivers) called `geckodriver` to run the project as-is. Make sure to [download and install](https://github.com/mozilla/geckodriver/releases) it before running the project.
 
 ## Run the Bandcamp Discover Player
 
-To run the music placer, navigate to the `src/` folder, then execute the module from your command-line:
+To run the music player, install the package, then use the entry point command from your command-line:
 
 ```sh
-(venv) $ cd src/
-(venv) $ python -m bandcamp
+(venv) $ python -m pip install .
+(venv) $ bandcamp-player
 ```
 
 You'll see a text-based user interface that allows you to interact with the music player:
 
 ```
-Type: [play <track number>], [tracks], [more], [exit]
+Type: play [<track_number>] | tracks | more | exit
 >
 ```
 
@@ -39,4 +41,4 @@ Bartosz Zaczyński - Email: [email protected]
 
 ## License
 
-Distributed under the MIT license. See ``LICENSE`` for more information.
+Distributed under the MIT license. See `LICENSE` for more information.

python-selenium/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "bandcamp_player"
 version = "0.1.0"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 description = "A web player for Bandcamp using Selenium"
 authors = [
     { name = "Martin Breuss", email = "[email protected]" },
@@ -16,6 +16,3 @@ dependencies = [
 ]
 [project.scripts]
 bandcamp-player = "bandcamp.__main__:main"
-
-[tool.setuptools.packages.find]
-where = ["src"]

python-selenium/requirements.txt

@@ -1,22 +1,15 @@
-appdirs==1.4.4
 attrs==24.2.0
-certifi==2024.7.4
+certifi==2024.8.30
 h11==0.14.0
-idna==3.7
-jedi==0.19.1
+idna==3.10
 outcome==1.3.0.post0
-parso==0.8.4
-prompt_toolkit==3.0.47
-ptpython==3.0.29
-Pygments==2.18.0
 PySocks==1.7.1
-selenium==4.23.1
+selenium==4.25.0
 sniffio==1.3.1
 sortedcontainers==2.4.0
-trio==0.26.1
+trio==0.27.0
 trio-websocket==0.11.1
 typing_extensions==4.12.2
-urllib3==2.2.2
-wcwidth==0.2.13
+urllib3==2.2.3
 websocket-client==1.8.0
 wsproto==1.2.0

python-selenium/src/bandcamp/__main__.py

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

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

@@ -4,11 +4,11 @@
 from bandcamp.web.element import TrackElement
 from bandcamp.web.page import HomePage
 
-BANDCAMP_FRONTPAGE = "https://bandcamp.com/"
+BANDCAMP_FRONTPAGE_URL = "https://bandcamp.com/"
 
 
 class Player:
-    """Plays tracks from Bandcamp's Discover section."""
+    """Play tracks from Bandcamp's Discover section."""
 
     def __init__(self) -> None:
         self._driver = self._set_up_driver()
@@ -22,11 +22,11 @@ def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb):
-        """Closes the headless browser."""
+        """Close the headless browser."""
         self._driver.close()
 
     def play(self, track_number=None):
-        """Plays the first track, or one of the available numbered tracks."""
+        """Play the first track, or one of the available numbered tracks."""
         if track_number:
             self._current_track = TrackElement(
                 self.home.discover_tracklist.available_tracks[
@@ -37,9 +37,9 @@ def play(self, track_number=None):
         self._current_track.play()
 
     def _set_up_driver(self):
-        """Creates a headless browser pointing to Bandcamp."""
+        """Create a headless browser pointing to Bandcamp."""
         options = Options()
         options.add_argument("--headless")
         browser = Firefox(options=options)
-        browser.get(BANDCAMP_FRONTPAGE)
+        browser.get(BANDCAMP_FRONTPAGE_URL)
         return browser

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

@@ -1,66 +1,61 @@
-from bandcamp.app.player import Player
-
+"""Provide a text-based user interface for a Bandcamp music player."""
 
-class TUI:
-    """Provides a text-based user interface for a Bandcamp music player."""
+from bandcamp.app.player import Player
 
-    COLUMN_WIDTH = CW = 30
+COLUMN_WIDTH = CW = 30
 
-    def interact(self):
-        """Controls the player through user interactions."""
-        with Player() as player:
-            while True:
-                print(
-                    "\nType: [play <track number>], [tracks], [more], [exit]"
-                )
-                command = input("> ").strip().lower()
 
-                if command.startswith("play"):
+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]:
                     try:
-                        track_number = int(command.split()[1])
-                        self.play(player, track_number)
-                    except IndexError:  # Play first track.
-                        self.play(player)
+                        track_number = int(track)
+                        play(player, track_number)
                     except ValueError:
                         print("Please provide a valid track number.")
-                elif command == "tracks":
-                    self.tracks(player)
-                elif command == "more":
+                case ["tracks"]:
+                    display_tracks(player)
+                case ["more"]:
                     player.discover.load_more()
-                    self.tracks(player)
-                elif command == "exit":
+                    display_tracks(player)
+                case ["exit"]:
                     print("Exiting the player...")
                     break
-                else:
+                case _:
                     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 tracks(self, player):
-        """Displays information about the currently playable tracks."""
-        header = (
-            f"{'#':<5} {'Album':<{self.CW}} "
-            f"{'Artist':<{self.CW}} "
-            f"{'Genre':<{self.CW}}"
+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}}"
         )
-        print(header)
-        print("-" * 100)
-        for track_number, track in enumerate(
-            player.discover.available_tracks, start=1
-        ):
-            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}}"
-            )
 
-    @staticmethod
-    def _truncate(text, width):
-        """Truncates track information."""
-        return text[: width - 3] + "..." if len(text) > width else text
+
+def _truncate(text, width):
+    """Truncate track information."""
+    return text[: width - 3] + "..." if len(text) > width else text

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

@@ -2,14 +2,14 @@
 from selenium.webdriver.remote.webelement import WebElement
 
 from bandcamp.web.base import Track, WebComponent
-from bandcamp.web.locators import HomePageLocatorMixin, TrackLocatorMixin
+from bandcamp.web.locators import HomePageLocator, TrackLocator
 
 
-class TrackElement(WebComponent, TrackLocatorMixin):
-    """Models a playable track in Bandcamp's Discover section."""
+class TrackElement(WebComponent, TrackLocator):
+    """Model a playable track in Bandcamp's Discover section."""
 
     def play(self) -> None:
-        """Plays the track."""
+        """Play the track."""
         if not self.is_playing():
             self._get_play_button().click()
             self._wait.until(lambda _: self.is_playing())
@@ -18,7 +18,7 @@ def is_playing(self) -> bool:
         return "playing" in self._get_play_button().get_attribute("class")
 
     def _get_track_info(self) -> Track:
-        """Creates a representation of the track's relevant information."""
+        """Create a representation of the track's relevant information."""
         full_url = self._parent.find_element(*self.ALBUM).get_attribute("href")
         # Cut off the referrer query parameter
         clean_url = full_url.split("?")[0] if full_url else ""
@@ -33,23 +33,23 @@ def _get_play_button(self):
         return self._parent.find_element(*self.PLAY_BUTTON)
 
 
-class DiscoverTrackList(WebComponent, HomePageLocatorMixin):
-    """Models the track list in Bandcamp's Discover section."""
+class DiscoverTrackList(WebComponent, HomePageLocator):
+    """Model 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:
-        """Loads additional tracks in the Discover section."""
+        """Load additional tracks in the Discover section."""
         self._get_next_page_button().click()
         self.available_tracks = self._get_available_tracks()
 
     def _get_available_tracks(self) -> list:
-        """Finds all currently available tracks in the Discover section."""
+        """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()]
 
     def _get_next_page_button(self):
-        """Locates and returns the 'Next' button that loads more results."""
+        """Locate and return the 'Next' button that loads more results."""
         return self._driver.find_elements(*self.PAGINATION_BUTTON)[-1]

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

@@ -1,13 +1,13 @@
 from selenium.webdriver.common.by import By
 
 
-class HomePageLocatorMixin:
+class HomePageLocator:
     DISCOVER_RESULTS = (By.CLASS_NAME, "discover-results")
     TRACK = (By.CLASS_NAME, "discover-item")
     PAGINATION_BUTTON = (By.CLASS_NAME, "item-page")
 
 
-class TrackLocatorMixin:
+class TrackLocator:
     PLAY_BUTTON = (By.CSS_SELECTOR, "a")
     ALBUM = (By.CLASS_NAME, "item-title")
     GENRE = (By.CLASS_NAME, "item-genre")

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

@@ -2,11 +2,11 @@
 
 from bandcamp.web.base import WebPage
 from bandcamp.web.element import DiscoverTrackList
-from bandcamp.web.locators import HomePageLocatorMixin
+from bandcamp.web.locators import HomePageLocator
 
 
-class HomePage(WebPage, HomePageLocatorMixin):
-    """Models the relevant parts of the Bandcamp home page."""
+class HomePage(WebPage, HomePageLocator):
+    """Model the relevant parts of the Bandcamp home page."""
 
     def __init__(self, driver: WebDriver) -> None:
         super().__init__(driver)