from typing import Optional import requests import logging LOGGER = logging.getLogger("this shouldn't be used") from ..utils import shared from ..objects import ( Song, Source, Album, Artist, Lyrics, Target, MusicObject, Options, SourcePages ) class Page: """ This is an abstract class, laying out the functionality for every other class fetching something """ API_SESSION: requests.Session = requests.Session() API_SESSION.proxies = shared.proxies TIMEOUT = 5 TRIES = 5 SOURCE_TYPE: SourcePages @classmethod def get_request(cls, url: str, accepted_response_codes: set = set((200,)), trie: int = 0) -> Optional[ requests.Request]: try: r = cls.API_SESSION.get(url, timeout=cls.TIMEOUT) except requests.exceptions.Timeout: return None if r.status_code in accepted_response_codes: return r LOGGER.warning(f"{cls.__name__} responded wit {r.status_code} at {url}. ({trie}-{cls.TRIES})") LOGGER.debug(r.content) if trie <= cls.TRIES: LOGGER.warning("to many tries. Aborting.") return cls.get_request(url, accepted_response_codes, trie + 1) @classmethod def post_request(cls, url: str, json: dict, accepted_response_codes: set = set((200,)), trie: int = 0) -> Optional[ requests.Request]: try: r = cls.API_SESSION.post(url, json=json, timeout=cls.TIMEOUT) except requests.exceptions.Timeout: return None if r.status_code in accepted_response_codes: return r LOGGER.warning(f"{cls.__name__} responded wit {r.status_code} at {url}. ({trie}-{cls.TRIES})") LOGGER.debug(r.content) if trie <= cls.TRIES: LOGGER.warning("to many tries. Aborting.") return cls.post_request(url, accepted_response_codes, trie + 1) class Query: def __init__(self, query: str): self.query = query self.is_raw = False self.artist = None self.album = None self.song = None self.parse_query(query=query) def __str__(self): if self.is_raw: return self.query return f"{self.artist}; {self.album}; {self.song}" def parse_query(self, query: str): if not '#' in query: self.is_raw = True return query = query.strip() parameters = query.split('#') parameters.remove('') for parameter in parameters: splitted = parameter.split(" ") type_ = splitted[0] input_ = " ".join(splitted[1:]).strip() if type_ == "a": self.artist = input_ continue if type_ == "r": self.album = input_ continue if type_ == "t": self.song = input_ continue def get_str(self, string): if string is None: return "" return string artist_str = property(fget=lambda self: self.get_str(self.artist)) album_str = property(fget=lambda self: self.get_str(self.album)) song_str = property(fget=lambda self: self.get_str(self.song)) @classmethod def search_by_query(cls, query: str) -> Options: """ # The Query You can define a new parameter with "#", the letter behind it defines the *type* of parameter, followed by a space "#a Psychonaut 4 #r Tired, Numb and #t Drop by Drop" if no # is in the query it gets treated as "unspecified query" # Functionality Returns the best matches from this page for the query, passed in. :param query: :return possible_music_objects: """ return Options() @classmethod def fetch_details(cls, music_object: MusicObject, flat: bool = False) -> MusicObject: """ when a music object with laccing data is passed in, it returns the SAME object **(no copy)** with more detailed data. If you for example put in an album, it fetches the tracklist :param music_object: :param flat: if it is true it fetches only the most important information (only one level) if an Artist is passed in, it fetches only the discography of the artist, and not the tracklist of every album of the artist. :return detailed_music_object: IT MODIFIES THE INPUT OBJ """ if type(music_object) == Song: song = cls.fetch_song_details(music_object, flat=flat) song.compile() return song if type(music_object) == Album: album = cls.fetch_album_details(music_object, flat=flat) album.compile() return album if type(music_object) == Artist: artist = cls.fetch_artist_details(music_object, flat=flat) artist.compile() return artist raise NotImplementedError(f"MusicObject {type(music_object)} has not been implemented yet") @classmethod def fetch_song_from_source(cls, source: Source, flat: bool = False) -> Song: return Song() @classmethod def fetch_song_details(cls, song: Song, flat: bool = False) -> Song: """ for a general description check cls.fetch_details :param song: song without much data :param flat: when True it only fetches the artist and the album, and the attributes of those, who can be gotten with one api request when False it fetches everything including, but not limited to: - Lyrics - Album + Tracklist (for tracksort) :return detailed_song: it modifies the input song """ source: Source for source in song.source_collection.get_sources_from_page(cls.SOURCE_TYPE): new_song = cls.fetch_song_from_source(source, flat) song.merge(new_song) return song @classmethod def fetch_album_from_source(cls, source: Source, flat: bool = False) -> Album: return Album() @classmethod def fetch_album_details(cls, album: Album, flat: bool = False) -> Album: """ for a general description check cls.fetch_details :param album: album without much data :param flat: when True it only fetches the artist and the tracklist, and the attributes of those, which can be gotten with one api request when False it fetches everything including, but not limited to: - Lyrics of every song - Artist, Album, Tracklist - every attribute of those :return detailed_artist: it modifies the input artist """ source: Source for source in album.source_collection.get_sources_from_page(cls.SOURCE_TYPE): new_album: Album = cls.fetch_album_from_source(source, flat) album.merge(new_album) return album @classmethod def fetch_artist_from_source(cls, source: Source, flat: bool = False) -> Artist: return Artist() @classmethod def fetch_artist_details(cls, artist: Artist, flat: bool = False) -> Artist: """ for a general description check cls.fetch_details :param artist: artist without much data :param flat: when True it only fetches the discographie, meaning every album, but not every tracklist when False it fetches everything including, but not limited to: - the whole discography - the tracklist of every album in the discography :return detailed_artist: it modifies the input artist """ source: Source for source in artist.source_collection.get_sources_from_page(cls.SOURCE_TYPE): new_artist: Artist = cls.fetch_artist_from_source(source, flat) artist.merge(new_artist) return artist