wpn 0.1.0__py3-none-any.whl

wpn/__init__.py

@@ -0,0 +1,370 @@
+"""
+WPN (What's Playing Now) Web Scraper
+
+This module provides functionality to scrape song information from the Muzak WPN website.
+It retrieves current and historical song data for various music channels/stations.
+
+The WPN class provides methods to:
+- Get a directory of available channels
+- Retrieve the current song playing on a specific channel
+- Get a list of previous songs played on a channel
+- Get a complete list of current and previous songs for a channel
+- Fetch and process all song data for all available channels
+
+Usage:
+    from wpn import WPN
+
+    # Create an instance
+    wpn = WPN()
+
+    # Get all available channels
+    channels = wpn.channel_list
+
+    # Get current song on a specific channel
+    song, artist = wpn.get_current_song("Channel Name")
+
+    # Get all songs (current and previous) for a channel
+    songs = wpn.get_all_songs("Channel Name")
+
+    # Get previous songs using negative indices
+    recent_song = songs[-1]  # Most recently played song (before current)
+    two_songs_ago = songs[-2]  # Second most recently played song
+
+    # Get all song data for all channels
+    all_data = wpn.get_all_song_data()
+"""
+
+from importlib.metadata import version
+
+__version__ = version("wpn")  # Uses installed package metadata
+
+import json
+import os
+import re
+from typing import Union
+
+import click
+import grequests
+import requests
+from bs4 import BeautifulSoup
+from thefuzz import process
+
+BASEADDR = "http://muzakwpn.muzak.com/"
+
+
+class WPN:
+    def __init__(self):
+        self.directory = self._get_directory()
+        self.song_data = {k: {"url": v} for k, v in self.directory.items()}
+        self.channel_list = list(self.directory.keys())
+        self.urls = list(self.directory.values())
+
+    def _get_soup(self, html: str) -> BeautifulSoup:
+        """Given html, return a BeautifulSoup object.
+
+        Args:
+            html (str): HTML document
+
+        Returns:
+            BeautifulSoup: Parsable object of the html document.
+        """
+        return BeautifulSoup(html, "html.parser")
+
+    def _get_directory(self, sort: bool = True) -> dict[str, dict[str, str]]:
+        """Create an up-to-date directory of channels and urls from the WPN website.
+
+        Args:
+            sort (bool, optional): Whether to sort the directory. Defaults to True.
+
+        Returns:
+            dict[str,str]: The directory of channel keys matched with the channel url.
+        """
+        html = requests.get(BASEADDR).text
+        soup = self._get_soup(html)
+        crumblinks = soup.find_all(class_="crumblink")
+        wpnaddr = re.compile(r"wpn/...\.html")
+        self.directory = {
+            crumblink.text: os.path.join(
+                BASEADDR, wpnaddr.findall(crumblink["onclick"])[0]
+            )
+            for crumblink in crumblinks[1:]
+        }
+        if sort:
+            self.directory = dict(
+                sorted(self.directory.items(), key=lambda item: item[0])
+            )
+        return self.directory
+
+    def _split_song(self, song: str) -> tuple[str, str]:
+        """Given an artist and song as a string, convert it into a tuple.
+
+        Args:
+            song (str): A string containing song and artist information.
+
+        Returns:
+            tuple[str, str]: A tuple containing (song, artist).
+        """
+        # Check if song is a Tag object from BeautifulSoup
+        if hasattr(song, "text"):
+            text = song.text.strip()
+        else:
+            text = str(song).strip()
+
+        # Split by ", by " to separate song and artist
+        parts = text.split(", by ", 1)
+        if len(parts) > 1:
+            return (parts[0].strip(), parts[1].strip())
+        else:
+            return (parts[0].strip(), "Unknown Artist")
+
+    def _get_song_list_from_html(self, html: str) -> tuple[str, list[tuple[str, str]]]:
+        """Given the html for a channel, generate a song list.
+
+        Args:
+            html (str): HTML document for a channel URL
+
+        Returns:
+            tuple[str, list[tuple[str, str]]]: A tuple containing the channel name and
+                                            a list of tuples containing (song, artist) info.
+                                            Index 0 is current song, negative indices refer
+                                            to previous songs chronologically (-1 is most recent).
+        """
+        soup = self._get_soup(html)
+        all_channel_data = soup.find(id="titles")
+        # get the channel name
+        channel_name = all_channel_data.find("p").find("b").text.replace("Now on ", "")
+        # get first song (current song)
+        current_song = self._split_song(list(all_channel_data.children)[0].contents[-1])
+        # list for previous songs that will be reversed
+        previous_songs = []
+
+        # try to add additional songs
+        try:
+            # add second song to previous_songs
+            previous_songs.append(self._split_song(list(all_channel_data.children)[2]))
+            # add songs 3-10 to previous_songs
+            previous_songs.extend(
+                self._split_song(song)
+                for song in list(all_channel_data.children)[3]
+                if len(song.text) > 1
+            )
+            # reverse previous_songs so that most recent is last (for negative indexing)
+            previous_songs.reverse()
+            # combine current song with reversed previous songs
+            song_list = [current_song] + previous_songs
+            return channel_name, song_list
+        except IndexError:
+            return channel_name, [current_song]
+
+    def _get_all_channels(self, urls: list[str]) -> list[requests.models.Response]:
+        """Given a list of URLs, perform simultaneous GET requests on those and return
+        the data as a list.
+
+        Args:
+            urls (list[str]): A list of URLs.
+
+        Returns:
+            list[requests.models.Response]: A list of requests Response objects from the URLs.
+        """
+        reqs = (grequests.get(url) for url in urls)
+        web_data = grequests.map(reqs)
+        return web_data
+
+    def get_channel_name(self, channel_input: Union[int, str]) -> str:
+        """Filter input to match a valid channel name.  Or, accept an integer to get a
+        channel by index.
+
+        Args:
+            channel_input (Union[int, str]): User input for the channel.
+
+        Returns:
+            str: A valid channel name from the WPN website.
+        """
+        if channel_input in self.channel_list:
+            return channel_input
+        elif isinstance(channel_input, int):
+            return self.channel_list[channel_input]
+        else:
+            return process.extractOne(channel_input, self.channel_list)[0]
+
+    def get_all_song_data(self) -> dict:
+        """Generate the song data for all songs currently playing.
+
+        Returns:
+            dict: A dictionary of all the WPN data.
+        """
+        # get the webdata
+        web_data = self._get_all_channels(self.urls)
+        # cycle through the responses, extract the channel name and song list,
+        # and add to the song_data
+        for channel in web_data:
+            channel_name, song_list = self._get_song_list_from_html(channel.text)
+            channel_name = self.get_channel_name(channel_name)
+            self.song_data[channel_name].update({"song_list": song_list})
+        return self.song_data
+
+    def get_current_song(self, channel_input: Union[str, int]) -> tuple[str, str]:
+        """Given a channel name or index, get the current song and artist.
+
+        Args:
+            channel_input (Union[str, int]): The name of the channel, or index number.
+
+        Returns:
+            tuple[str, str]: The current song as a tuple (song, artist).
+        """
+        channel_name = self.get_channel_name(channel_input)
+        song_data = self.get_all_song_data()
+        return song_data[channel_name]["song_list"][0]
+
+    def get_previous_songs(
+        self, channel_input: Union[str, int]
+    ) -> list[tuple[str, str]]:
+        """Given a channel name or index, get the previous songs and artists.
+
+        Args:
+            channel_input (Union[str, int]): The name of the channel, or index number.
+
+        Returns:
+            list[tuple[str, str]]: A list of previous songs as tuples (song, artist).
+                                  Ordered from oldest to most recent.
+        """
+        channel_name = self.get_channel_name(channel_input)
+        song_data = self.get_all_song_data()
+        # Return all songs except the current one (index 0), in the order they appear
+        return song_data[channel_name]["song_list"][1:]
+
+    def get_all_songs(self, channel_input: Union[str, int]) -> list[tuple[str, str]]:
+        """Given a channel name or index, get current and previous songs and artists.
+
+        Args:
+            channel_input (Union[str, int]): The name of the channel, or index number.
+
+        Returns:
+            list[tuple[str, str]]: A list of current and previous songs
+            as tuples (song, artist).
+        """
+        channel_name = self.get_channel_name(channel_input)
+        song_data = self.get_all_song_data()
+        return song_data[channel_name]["song_list"]
+
+
+@click.group()
+def cli():
+    """Command-line interface for the WPN (What's Playing Now) web scraper."""
+    pass
+
+
+@cli.command(
+    "all-data", help="Get all song data for all channels and save to a JSON file."
+)
+@click.option(
+    "--output",
+    "-o",
+    type=str,
+    default="output/output.json",
+    help="Path to save the JSON output file",
+)
+def all_data(output):
+    """Get all song data for all channels and save to a JSON file."""
+    try:
+        wpn = WPN()
+        data = wpn.get_all_song_data()
+
+        # Ensure output directory exists
+        os.makedirs(os.path.dirname(output), exist_ok=True)
+
+        with open(output, "w", encoding="UTF-8") as f:
+            json.dump(data, f, indent=2)
+
+        click.echo(f"Data saved to {output} with {len(data)} channels")
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@cli.command("list", help="List all available music channels.")
+def list_channels():
+    """List all available music channels."""
+    wpn = WPN()
+    channels = wpn.channel_list
+    click.echo(f"Available channels ({len(channels)}):")
+    for i, channel in enumerate(channels):
+        click.echo(f"{i}: {channel}")
+
+
+@cli.command("songs", help="Get all songs (current and previous) for a channel.")
+@click.argument("channel", type=str)
+def all_songs(channel):
+    """Get all songs (current and previous) for a channel.
+
+    CHANNEL can be the exact channel name, a partial name that will be matched,
+    or an index number from the list command.
+    """
+    wpn = WPN()
+    try:
+        # Handle integer input
+        if channel.isdigit():
+            channel = int(channel)
+
+        channel_name = wpn.get_channel_name(channel)
+        songs = wpn.get_all_songs(channel)
+        click.echo(f"All songs on {channel_name}:")
+        click.echo(f"Currently playing: {songs[0][0]} by {songs[0][1]}")
+        if len(songs) > 1:
+            click.echo("Previously played (most recent first):")
+            # Show previous songs in reverse order (most recent first)
+            for i, (song, artist) in enumerate(reversed(songs[1:]), 1):
+                click.echo(f"{i}. {song} by {artist}")
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@cli.command("current", help="Get the current song playing on a specific channel.")
+@click.argument("channel", type=str)
+def current_song(channel):
+    """Get the current song playing on a specific channel.
+
+    CHANNEL can be the exact channel name, a partial name that will be matched,
+    or an index number from the list command.
+    """
+    wpn = WPN()
+    try:
+        # Handle integer input
+        if channel.isdigit():
+            channel = int(channel)
+
+        channel_name = wpn.get_channel_name(channel)
+        song, artist = wpn.get_current_song(channel)
+        click.echo(f"Channel: {channel_name}")
+        click.echo(f"Now playing: {song} by {artist}")
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@cli.command("previous", help="Get a list of previous songs played on a channel.")
+@click.argument("channel", type=str)
+def previous_songs(channel):
+    """Get a list of previous songs played on a channel.
+
+    CHANNEL can be the exact channel name, a partial name that will be matched,
+    or an index number from the list command.
+    """
+    wpn = WPN()
+    try:
+        # Handle integer input
+        if channel.isdigit():
+            channel = int(channel)
+
+        channel_name = wpn.get_channel_name(channel)
+        songs = wpn.get_previous_songs(channel)
+        click.echo(f"Previous songs on {channel_name} (most recent first):")
+
+        # Reverse the order to show most recent first
+        songs_to_display = list(reversed(songs))
+        for i, (song, artist) in enumerate(songs_to_display, 1):
+            click.echo(f"{i}. {song} by {artist}")
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+if __name__ == "__main__":
+    cli()

wpn-0.1.0.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: wpn
+Version: 0.1.0
+Summary: A Python library for scraping and retrieving song information from the Muzak WPN (What's Playing Now) website. This tool allows you to get current and historical song data for various music channels/stations.
+Author-email: Lance Reinsmith <info@k2rad.com>
+License: MIT
+Keywords: music,song,scraping,wpn,muzak
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: beautifulsoup4
+Requires-Dist: click
+Requires-Dist: grequests
+Requires-Dist: python-Levenshtein
+Requires-Dist: requests
+Requires-Dist: thefuzz
+
+# WPN - What's Playing Now
+
+A Python library for scraping and retrieving song information from the Muzak WPN (What's Playing Now) website. This tool allows you to get current and historical song data for various music channels/stations.
+
+## Features
+
+- Get a directory of available music channels
+- Retrieve the current song playing on a specific channel
+- Get a list of previous songs played on a channel
+- Get a complete list of current and previous songs for a channel
+- Fetch and process all song data for all available channels
+- Export song data to JSON format
+- Command-line interface for all functionality
+
+## Installation
+
+### Requirements
+
+- Python 3.12 or higher
+- Dependencies are specified in `pyproject.toml`
+
+### Installation steps
+
+1. Clone this repository:
+   ```
+   git clone https://github.com/lancereinsmith/wpn.git
+   cd wpn
+   ```
+
+2. Install using `uv` (recommended):
+   ```
+   pip install uv
+   uv venv
+   uv pip install -e .
+   ```
+
+3. Alternatively, you can use a standard venv:
+   ```
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows, use `.venv\Scripts\activate`
+   pip install -e .
+   ```
+
+## Usage
+
+### Python API Usage
+
+```python
+from wpn import WPN
+
+# Create an instance
+wpn = WPN()
+
+# Get all available channels
+channels = wpn.channel_list
+print(f"Available channels: {len(channels)}")
+
+# Get current song on a specific channel (by name or index)
+song, artist = wpn.get_current_song("Channel Name")  # Using channel name
+# Or
+song, artist = wpn.get_current_song(5)  # Using channel index
+print(f"Now playing: {song} by {artist}")
+
+# Get all songs (current and previous) for a channel
+songs = wpn.get_all_songs("Channel Name")  # Using channel name
+# Or
+songs = wpn.get_all_songs(5)  # Using channel index
+
+# Current song is at index 0
+current_song, current_artist = songs[0]
+print(f"Now playing: {current_song} by {current_artist}")
+
+# Previous songs can be accessed using negative indices
+# Most recent previous song
+if len(songs) > 1:
+    prev_song, prev_artist = songs[-1]
+    print(f"Previously played: {prev_song} by {prev_artist}")
+    
+    # Second most recent previous song
+    if len(songs) > 2:
+        older_song, older_artist = songs[-2]
+        print(f"Before that: {older_song} by {older_artist}")
+
+# Or iterate through all songs
+for i, (song, artist) in enumerate(songs):
+    if i == 0:
+        print(f"Current: {song} by {artist}")
+    else:
+        print(f"Previous ({len(songs)-i}): {song} by {artist}")
+
+# Get previous songs only (by name or index)
+previous_songs = wpn.get_previous_songs("Channel Name")  # Using channel name
+# Or
+previous_songs = wpn.get_previous_songs(5)  # Using channel index
+
+# Get all song data for all channels
+all_data = wpn.get_all_song_data()
+```
+
+### Command-Line Interface
+
+WPN provides a comprehensive command-line interface for accessing all functionality.
+
+After installing the package, the `wpn` command will be available:
+
+```
+wpn --help
+```
+
+#### List all available channels
+
+```
+wpn list
+```
+
+#### Get the current song playing on a channel
+
+```
+wpn current "Channel Name"
+# Or using channel index
+wpn current 5
+```
+
+#### Get previous songs played on a channel
+
+```
+wpn previous "Channel Name"
+# Or using channel index
+wpn previous 5
+```
+
+This will display a list of previously played songs from most recent to least recent.
+
+#### Get all songs (current and previous) for a channel
+
+```
+wpn songs "Channel Name"
+# Or using channel index
+wpn songs 5
+```
+
+#### Get all song data for all channels
+
+```
+wpn all-data
+# Or specify custom output path
+wpn all-data --output data.json
+```
+
+## API Reference
+
+### WPN Class
+
+#### `__init__()`
+Initialize the WPN scraper with an up-to-date directory of channels.
+
+#### `get_directory(sort=True)`
+Create an up-to-date directory of channels and URLs from the WPN website.
+
+#### `get_channel_name(channel_input)`
+Filter input to match a valid channel name or accept an integer to get a channel by index.
+
+#### `get_current_song(channel_input)`
+Get the current song playing on a specified channel, returned as a tuple of (song, artist).
+The `channel_input` can be either a string (channel name) or an integer (channel index).
+
+#### `get_previous_songs(channel_input)`
+Get a list of previous songs played on a channel as a list of (song, artist) tuples, ordered from oldest to most recent.
+The `channel_input` can be either a string (channel name) or an integer (channel index).
+
+#### `get_all_songs(channel_input)`
+Get a list of current and previous songs for a channel as a list of (song, artist) tuples. The list is structured so that:
+- Index 0 contains the current song
+- Negative indices can be used to access previous songs chronologically
+- songs[-1] is the most recently played previous song
+- songs[-2] is the second most recently played previous song, and so on
+
+The `channel_input` can be either a string (channel name) or an integer (channel index).
+
+#### `get_all_song_data()`
+Generate the song data for all songs currently playing on all channels.
+
+## Project Structure
+
+```wpn/
+├── src/
+│   └── wpn/
+│       ├── __init__.py
+│       └── wpn.py
+├── tests/
+│   └── test_wpn.py
+├── pyproject.toml
+└── README.md
+```
+
+## Testing
+
+Run tests using pytest:
+
+```
+python -m pytest
+```
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+

wpn-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+wpn/__init__.py,sha256=rlnVZ8ZmInu-WUfRJG-3Jir4blCyfmMvLJGIYPrdTpo,13102
+wpn-0.1.0.dist-info/METADATA,sha256=IOcwa2yYhLwK5jsl8fAjdjNQddtRfMCGuB0cPFP-YYE,6280
+wpn-0.1.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+wpn-0.1.0.dist-info/entry_points.txt,sha256=9oE4n_2iK_9UwuuQfXdb5dDkxixtcBx9GY-HvMPFW9s,32
+wpn-0.1.0.dist-info/top_level.txt,sha256=6bAm5Qnt2Gf5N_KBlOIPxo9fVlLRQKHKEAx2QX0CHYQ,4
+wpn-0.1.0.dist-info/RECORD,,

wpn-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wpn-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wpn = wpn:cli

wpn-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wpn