utils.py

import logging
import re
import time
from configparser import ConfigParser

import requests
from google.genai import Client
from lyricsgenius import Genius
from openai import OpenAI

config = ConfigParser()
config.read("config.ini")

gemini_client = Client(api_key=config["gemini"]["API_KEY"])
openai_client = OpenAI(api_key=config["openai"]["API_KEY"])

genius_client = Genius(access_token=config["genius"]["TOKEN"])
genius_client.verbose = False

WIKIDATA_API_URL = "https://www.wikidata.org/w/api.php"
INSTAGRAM_PROPERTY_ID = "P2003"  # P2003 is the Wikidata property for Instagram username


def create_hashtag(text: str) -> str:
    """
    Removes all non-alphanumeric characters from a string.

    Args:
        text: The input string.

    Returns:
        The string with only alphanumeric characters.
    """
    hash_text = re.sub(r"[^a-zA-Z0-9]", "", text.lower())
    return "#" + hash_text if hash_text else ""


def get_img_prompt(prompt: str) -> str:

    response = gemini_client.models.generate_content(
        model=config["gemini"]["MODEL"], contents=prompt
    )
    return response.text


def get_image(prompt: str) -> str | None:
    """Generate an image using OpenAI's DALL-E 3 model with a retry mechanism.

    Args:
        prompt: The text prompt for image generation.

    Returns:
        The URL of the generated image, or None if it fails after retries.
    """
    attempts = 2
    for i in range(attempts):
        try:
            img = openai_client.images.generate(
                model=config["openai"]["MODEL"],
                prompt=prompt,
                n=1,
                size="1024x1024",
                quality="standard",
                response_format="url",
            )
            print(f"dall-e revised prompt: {img.data[0].revised_prompt}")

            url = img.data[0].url
            print(f"Image URL: {url}")
            return url

        except Exception as e:
            # Wait a second before retrying
            if i < attempts - 1:
                time.sleep(1)
            else:
                logging.error(str(e))

    return None


def get_lyrics(song: str, artist: str) -> str | None:
    obj = genius_client.search_song(song, artist)
    if not obj:
        song = song.split(" - ", 1)[0].strip()
        obj = genius_client.search_song(song, artist)

    if obj:
        return (
            obj.lyrics.split("Lyrics", 1)[1]
            .split("You might also like")[0]
            .split("… Read More")[-1]
            .strip()
        )
    else:
        return None


def get_handle(artist: str) -> str | None:
    """
    Searches Wikidata for an artist and retrieves their Instagram username if available.

    Args:
        artist: The name of the artist to search for.

    Returns:
        The artist's Instagram username as a string, or None if not found.
    """
    # The requests library automatically URL-encodes parameters
    search_params = {
        "action": "wbsearchentities",
        "search": artist,
        "language": "en",
        "format": "json",
    }
    try:
        # Wikidata API requires a User-Agent header to avoid 403 Forbidden errors
        headers = {"User-Agent": "Slop/1.0 (https://github.com/mannmann2/slop)"}
        response = requests.get(WIKIDATA_API_URL, params=search_params, headers=headers)
        response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
        search_results = response.json()
    except requests.exceptions.RequestException as e:
        logging.error(f"Wikidata search request failed for '{artist}': {e}")
        return None
    except ValueError:  # Catches JSON decoding errors
        logging.error(f"Failed to decode JSON from Wikidata search for '{artist}'")
        return None

    if not search_results.get("search"):
        logging.info(f"No Wikidata search results for artist: '{artist}'")
        return None

    qid = search_results["search"][0].get("id")

    entity_params = {
        "action": "wbgetentities",
        "ids": qid,
        "format": "json",
        "props": "claims",
    }
    try:
        headers = {"User-Agent": "Slop/1.0 (https://github.com/mannmann2/slop)"}
        response = requests.get(WIKIDATA_API_URL, params=entity_params, headers=headers)
        response.raise_for_status()
        entity_data = response.json()
    except requests.exceptions.RequestException as e:
        logging.error(f"Wikidata entity request failed for QID '{qid}': {e}")
        return None
    except ValueError:
        logging.error(
            f"Failed to decode JSON from Wikidata entity request for QID '{qid}'"
        )
        return None

    # Safely navigate the nested structure to find the Instagram username
    try:
        claims = entity_data["entities"][qid]["claims"]
        instagram_claims = claims[INSTAGRAM_PROPERTY_ID]
        return instagram_claims[0]["mainsnak"]["datavalue"]["value"]
    except (KeyError, IndexError):
        # This is not an error, just means the property doesn't exist for this entity.
        logging.info(f"Could not find Instagram username for '{artist}' (QID: {qid}).")
        return None