BeatPrints 1.0.0__tar.gz

beatprints-1.0.0/BeatPrints/__init__.py

@@ -0,0 +1,4 @@
+from .spotify import *
+from .lyrics import *
+from .poster import *
+from .errors import *

beatprints-1.0.0/BeatPrints/consts.py

@@ -0,0 +1,51 @@
+"""
+Module: consts.py
+
+Contains all the necessary co-ordinates that'll
+be needed to place the texts/images on the poster.
+
+Prefixes
+---------
+S = Size
+C = Cords
+P = Path
+CL = Color
+"""
+
+import os
+
+MAX_ROWS = 5
+MAX_WIDTH = 1020
+
+S_TRACKS = 35
+S_SPACING = 45
+S_COVER = (1020, 1020)
+S_SPOTIFY_CODE = (330, 85)
+S_HEADING = 80
+S_ARTIST = 60
+S_DURATION = 45
+S_LYRICS = 42
+S_LABEL = 30
+
+C_COVER = (60, 60)
+C_HEADING = (60, 1275)
+C_ARTIST = (60, 1350)
+C_LYRICS = (60, 1395)
+C_TRACKS = (60, 1390)
+C_LABEL = (1080, 1615)
+
+C_DURATION = (1080, 1275)
+C_PALETTE = (60, 1120)
+C_ACCENT = (0, 1720, 1140, 1740)
+C_SPOTIFY_CODE = (45, 1610)
+
+CL_FONT_DARK_MODE = (193, 189, 178)
+CL_FONT_LIGHT_MODE = (50, 47, 48)
+
+CL_WHITE = (255, 255, 255, 255)
+CL_TRANSPARENT = (0, 0, 0, 0)
+
+P_FULLPATH = os.path.join(os.path.dirname(__file__))
+P_ASSETS = os.path.join(P_FULLPATH, "assets")
+P_FONTS = os.path.join(P_ASSETS, "fonts")
+P_TEMPLATES = os.path.join(P_ASSETS, "templates")

beatprints-1.0.0/BeatPrints/errors.py

@@ -0,0 +1,79 @@
+"""
+Module: errors.py
+
+Handles custom exceptions for error handling.
+"""
+
+class NoMatchingTrackFound(Exception):
+    """
+    Exception raised when no song matching the specified query is found.
+    """
+    def __init__(self, message="No track was found matching the query."):
+        self.message = message
+        super().__init__(self.message)
+
+
+class NoMatchingAlbumFound(Exception):
+    """
+    Exception raised when no album matching the specified query is found.
+    """
+    def __init__(self, message="No album was found matching the query."):
+        self.message = message
+        super().__init__(self.message)
+
+
+class NoLyricsAvailable(Exception):
+    """
+    Exception raised when no lyrics are available for the specified song.
+    """
+    def __init__(self, message="No lyrics were found for the specified song"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class InvalidSearchLimit(Exception):
+    """
+    Exception raised when an invalid search limit is specified for tracks or albums.
+    """
+    def __init__(self, message="The search limit must be set to at least 1."):
+        self.message = message
+        super().__init__(self.message)
+
+
+class InvalidSelectionError(Exception):
+    """
+    Exception raised when an invalid selection range is provided for lyrics.
+    """
+    def __init__(
+        self,
+        message="Invalid range format. Please use 'start-end', ensuring start is less than end.",
+    ):
+        self.message = message
+        super().__init__(self.message)
+
+
+class LineLimitExceededError(Exception):
+    """
+    Exception raised when the selection in lyrics contains more or fewer than 4 lines.
+    """
+    def __init__(self, message="Exactly 4 lines must be selected, no more, no less."):
+        self.message = message
+        super().__init__(self.message)
+
+
+class InvalidFormatError(Exception):
+    """
+    Exception raised when the format of the lyrics selection is invalid.
+    """
+    def __init__(self, message="Use format 'x-y' where x and y are numbers."):
+        self.message = message
+        super().__init__(self.message)
+
+
+class PathNotFoundError(Exception):
+    """
+    Exception raised when the specified path for saving images cannot be found.
+    """
+    def __init__(self, message="The specified path for saving images could not be found."):
+        self.message = message
+        super().__init__(self.message)

beatprints-1.0.0/BeatPrints/image.py

@@ -0,0 +1,210 @@
+"""
+Module: image.py
+
+Provides essential image functions to generate posters.
+"""
+
+import random
+import requests
+
+from io import BytesIO
+from typing import List, Tuple, Optional
+
+from Pylette import extract_colors
+from PIL import Image, ImageDraw, ImageEnhance
+
+from .consts import *
+from .errors import PathNotFoundError
+
+
+def get_palette(image: Image.Image) -> List[Tuple]:
+    """
+    Extracts a color palette from an image.
+
+    Args:
+        image (Image.Image): The image from which the color palette will be extracted.
+
+    Returns:
+        List[Tuple]: A list of RGB tuples representing the dominant colors in the image.
+    """
+
+    # Save the image to an in-memory byte stream in PNG format
+    with BytesIO() as byte_stream:
+        image.save(byte_stream, format="PNG")
+
+        # Get the byte data
+        img_bytes = byte_stream.getvalue()
+
+    # Extract the color palette
+    colors = extract_colors(image=img_bytes, palette_size=6, sort_mode="luminance")
+
+    # Return the color palette
+    return [tuple(color.rgb) for color in colors]
+
+
+def draw_palette(
+    draw: ImageDraw.ImageDraw, image: Image.Image, accent: bool = False
+) -> None:
+    """
+    Draws a color palette on the given image using Pillow.
+
+    Args:
+        draw (ImageDraw.ImageDraw): The drawing context for the image.
+        image (Image.Image): The image on which to draw the palette.
+        accent (bool): If True, highlights an accent color in the palette.
+    """
+
+    palette = get_palette(image)
+
+    # Draw the palette as rectangles on the image
+    for i in range(6):
+
+        # Calculate the position and size for each color rectangle
+        x, y = C_PALETTE
+        start, end = 170 * i, 170 * (i + 1)
+
+        # Draw the color rectangle
+        draw.rectangle(((x + start, y), (x + end, 1160)), fill=palette[i])
+
+    # Optionally draw the accent color at the bottom
+    if accent:
+        draw.rectangle(C_ACCENT, fill=palette[random.randint(0, 2)])
+
+
+def crop(path: str) -> Image.Image:
+    """
+    Crops an image to a square (1:1) aspect ratio.
+
+    Args:
+        path (str): The path to the image file.
+
+    Returns:
+        Image.Image: The cropped image with a 1:1 aspect ratio.
+
+    Raises:
+        PathNotFoundError: If the path to the image file doesn't exists
+    """
+
+    def chop(image: Image.Image) -> Image.Image:
+        # Get the dimensions of the image
+        width, height = image.size
+        min_dim = min(width, height)
+
+        # Calculate the cropping box to make the image square
+        left = (width - min_dim) / 2
+        top = (height - min_dim) / 2
+        right = (width + min_dim) / 2
+        bottom = (height + min_dim) / 2
+
+        # Crop and return the image
+        return image.crop((left, top, right, bottom))
+
+    if os.path.exists(path):
+        with Image.open(path) as img:
+            return chop(img)
+    else:
+        raise PathNotFoundError
+
+
+def magicify(image: Image.Image) -> Image.Image:
+    """
+    Adjusts the brightness and contrast of the image.
+
+    Args:
+        image (Image.Image): The image to be adjusted.
+
+    Returns:
+        Image.Image: The adjusted image with modified brightness and contrast.
+    """
+
+    # Reduce brightness by 10%
+    brightness = ImageEnhance.Brightness(image)
+    image_brightness = brightness.enhance(0.9)
+
+    # Reduce contrast by 20%
+    contrast = ImageEnhance.Contrast(image_brightness)
+    image_contrast = contrast.enhance(0.8)
+
+    return image_contrast
+
+
+def scannable(id: str, darktheme: bool = False, is_album: bool = False) -> Image.Image:
+    """
+    Generates a Spotify scannable code (QR code) for a track or album.
+
+    Args:
+        id (str): The ID of the track or album on Spotify.
+        darktheme (bool): Flag to indicate whether to use a dark theme (default is False).
+        is_album (bool): Flag to indicate if the ID is for an album (default is False).
+
+    Returns:
+        Image.Image: A resized and transparent Spotify scannable code image.
+    """
+
+    # Set the color based on the theme
+    color = CL_FONT_DARK_MODE if darktheme else CL_FONT_LIGHT_MODE
+
+    # Build the URL for the Spotify scannable code
+    item_type = "album" if is_album else "track"
+    scan_url = f"https://scannables.scdn.co/uri/plain/png/101010/white/1280/spotify:{item_type}:{id}"
+
+    # Download the scannable image data
+    data = requests.get(scan_url).content
+    img_bytes = BytesIO(data)
+
+    # Process the image to make white pixels transparent
+    with Image.open(img_bytes) as scan_code:
+
+        # Convert the image to RGBA mode to support transparency
+        scan_code = scan_code.convert("RGBA")
+        width, height = scan_code.size
+        pixels = scan_code.load()
+
+        # Replace white pixels with transparency, others with the selected color
+        for x in range(width):
+            for y in range(height):
+                if pixels is not None:
+                    pixels[x, y] = CL_TRANSPARENT if pixels[x, y] != CL_WHITE else color
+
+        # Resize the image to specific size
+        resized = scan_code.resize(S_SPOTIFY_CODE, Image.Resampling.BICUBIC)
+
+    return resized
+
+
+def cover(image_url: str, path: Optional[str]) -> Image.Image:
+    """
+    Fetches and processes an image from a URL or a local path.
+
+    Args:
+        image_url (str): The URL to fetch the image from.
+        path (Optional[str]): Local path to the custom image.
+
+    Returns:
+        Image.Image: The processed image.
+    """
+
+    # Load image from a path or fetch from URL
+    img = crop(path) if path else Image.open(BytesIO(requests.get(image_url).content))
+
+    # Apply magic filter  and resize
+    return magicify(img.resize(S_COVER))
+
+
+def get_theme(dark_theme: bool):
+    """
+    Determines theme-related properties.
+
+    Args:
+        dark_theme (bool): Whether to use a dark theme.
+
+    Returns:
+        Tuple containing theme color, template path
+    """
+    color, template = (
+        (CL_FONT_DARK_MODE, "banner_dark.png")
+        if dark_theme
+        else (CL_FONT_LIGHT_MODE, "banner_light.png")
+    )
+    template_path = os.path.join(P_TEMPLATES, template)
+    return color, template_path

beatprints-1.0.0/BeatPrints/lyrics.py

@@ -0,0 +1,97 @@
+"""
+Module: lyrics.py
+
+Provide lyrics from LRClib API.
+"""
+
+import re
+from lrclib import LrcLibAPI
+
+from .spotify import TrackMetadata
+from .errors import (
+    NoLyricsAvailable,
+    InvalidFormatError,
+    InvalidSelectionError,
+    LineLimitExceededError,
+)
+
+
+class Lyrics:
+    """
+    This class helps to retrieve lyrics through LRClib API.
+    """
+
+    def get_lyrics(self, metadata: TrackMetadata) -> str:
+        """
+        Retrieve lyrics from LRClib.net for a given track and artist.
+
+        Args:
+            metadata (TrackMetadata): Instance that holds the metadata about a track.
+
+        Returns:
+            str: The lyrics in plain text if found.
+
+        Raises:
+            NoLyricsAvailable: If no lyrics are found for the given track and artist.
+        """
+        user_agent = (
+            "Mozilla/5.0 (X11; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0"
+        )
+
+        # Prepare the API
+        api = LrcLibAPI(user_agent=user_agent)
+        id = api.search_lyrics(track_name=metadata.name, artist_name=metadata.artist)
+
+        # Check if lyrics are available
+        if len(id) != 0:
+            lyrics = api.get_lyrics_by_id(id[0].id)
+            return str(lyrics.plain_lyrics)
+        else:
+            raise NoLyricsAvailable
+
+    def select_lines(self, lyrics: str, selection: str) -> str:
+        """
+        Selects a range of lines from the song lyrics.
+
+        Args:
+            lyrics (str): The lyrics of the song.
+            selection (str): Line range to extract in "start-end" format.
+
+        Returns:
+            str: The selected lines.
+
+        Raises:
+            InvalidFormatError: If the selection format is invalid.
+            InvalidSelectionError: If the selection range is invalid.
+            LineLimitExceededError: If the selected range doesn't contain exactly 4 lines.
+        """
+        lines = [line for line in lyrics.split("\n")]
+        line_count = len(lines)
+
+        try:
+            pattern = r"^\d+-\d+$"
+
+            if not re.match(pattern, selection):
+                raise InvalidFormatError
+
+            selected = [int(num) for num in selection.split("-")]
+
+            if (
+                len(selected) != 2
+                or selected[0] >= selected[1]
+                or selected[0] <= 0
+                or selected[1] > line_count
+            ):
+                raise InvalidSelectionError
+
+            extracted = lines[selected[0] - 1 : selected[1]]
+            selected_lines = [line for line in extracted if line != ""]
+
+            if len(selected_lines) != 4:
+                raise LineLimitExceededError
+
+            quatrain = "\n".join(selected_lines).strip()
+            return quatrain
+
+        except Exception as e:
+            raise e