Add lib

lib/ShazamIO/shazamio/schemas/artist/views/full_albums.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from shazamio.schemas.attributes import AttributeName
+from shazamio.schemas.base import BaseDataModel
+from shazamio.schemas.photos import ImageModel
+
+
+class PlayParams(BaseModel):
+    id: str
+    kind: str
+
+
+class EditorialArtwork(BaseModel):
+    subscription_hero: Optional[ImageModel] = Field(None, alias="subscriptionHero")
+    store_flow_case: Optional[ImageModel] = Field(None, alias="storeFlowcase")
+
+
+class EditorialNotes(BaseModel):
+    standard: Optional[str] = None
+    short: Optional[str] = None
+
+
+class AttributesFullAlbums(BaseModel):
+    copyright: str
+    genre_names: List[str] = Field(..., alias="genreNames")
+    release_date: str = Field(..., alias="releaseDate")
+    is_mastered_for_itunes: bool = Field(..., alias="isMasteredForItunes")
+    upc: str
+    artwork: ImageModel
+    play_params: PlayParams = Field(..., alias="playParams")
+    url: str
+    record_label: str = Field(..., alias="recordLabel")
+    track_count: int = Field(..., alias="trackCount")
+    is_compilation: bool = Field(..., alias="isCompilation")
+    is_prerelease: bool = Field(..., alias="isPrerelease")
+    audio_traits: List[str] = Field(..., alias="audioTraits")
+    editorial_artwork: EditorialArtwork = Field(..., alias="editorialArtwork")
+    is_single: bool = Field(..., alias="isSingle")
+    name: str
+    artist_name: str = Field(..., alias="artistName")
+    content_rating: Optional[str] = Field(None, alias="contentRating")
+    is_complete: bool = Field(..., alias="isComplete")
+    editorial_notes: Optional[EditorialNotes] = Field(None, alias="editorialNotes")
+
+
+class FullAlbumsModel(BaseModel):
+    href: Optional[str] = None
+    attributes: Optional[AttributeName] = None
+    data: Optional[List[BaseDataModel[AttributesFullAlbums]]] = None

lib/ShazamIO/shazamio/schemas/artist/views/last_release.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from shazamio.schemas.attributes import AttributeName
+from shazamio.schemas.base import BaseDataModel
+from shazamio.schemas.photos import ImageModel
+
+
+class PlayParams(BaseModel):
+    id: str
+    kind: str
+
+
+class AttributeLastRelease(BaseModel):
+    copyright: str
+    genre_names: List[str] = Field(..., alias="genreNames")
+    release_date: str = Field(..., alias="releaseDate")
+    is_mastered_for_itunes: bool = Field(..., alias="isMasteredForItunes")
+    upc: str
+    artwork: ImageModel
+    play_params: PlayParams = Field(..., alias="playParams")
+    url: str
+    record_label: str = Field(..., alias="recordLabel")
+    track_count: int = Field(..., alias="trackCount")
+    is_compilation: bool = Field(..., alias="isCompilation")
+    is_prerelease: bool = Field(..., alias="isPrerelease")
+    audio_traits: List[str] = Field(..., alias="audioTraits")
+    editorial_artwork: Dict[str, Any] = Field(..., alias="editorialArtwork")
+    is_single: bool = Field(..., alias="isSingle")
+    name: str
+    artist_name: str = Field(..., alias="artistName")
+    content_rating: Optional[str] = Field(None, alias="contentRating")
+    is_complete: bool = Field(..., alias="isComplete")
+
+
+class LastReleaseModel(BaseModel):
+    href: Optional[str] = None
+    attributes: Optional[AttributeName] = None
+    data: Optional[List[BaseDataModel[AttributeLastRelease]]] = None

lib/ShazamIO/shazamio/schemas/artist/views/simular_artists.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from shazamio.schemas.attributes import AttributeName
+from shazamio.schemas.base import BaseHrefNextData
+from shazamio.schemas.base import BaseIdTypeHref
+from shazamio.schemas.photos import ImageModel
+
+
+class EditorialArtwork(BaseModel):
+    centered_fullscreen_background: Optional[ImageModel] = Field(
+        None, alias="centeredFullscreenBackground"
+    )
+    subscription_hero: Optional[ImageModel] = Field(None, alias="subscriptionHero")
+    banner_uber: Optional[ImageModel] = Field(None, alias="bannerUber")
+
+
+class Attributes(BaseModel):
+    genre_names: List[str] = Field(..., alias="genreNames")
+    editorial_artwork: EditorialArtwork = Field(..., alias="editorialArtwork")
+    name: str
+    artwork: ImageModel
+    url: str
+    origin: Optional[str] = None
+    artist_bio: Optional[str] = Field(None, alias="artistBio")
+
+
+class Relationships(BaseModel):
+    albums: BaseHrefNextData[List[BaseIdTypeHref]]
+
+
+class Datum(BaseModel):
+    id: str
+    type: str
+    href: str
+    attributes: Attributes
+    relationships: Relationships
+
+
+class SimularArtist(BaseModel):
+    href: Optional[str] = None
+    next: Optional[str] = None
+    attributes: Optional[AttributeName] = None
+    data: Optional[List[Datum]] = None

lib/ShazamIO/shazamio/schemas/artist/views/top_music.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from shazamio.schemas.attributes import AttributeName
+from shazamio.schemas.base import BaseDataModel
+from shazamio.schemas.photos import ImageModel
+
+
+class PlayParams(BaseModel):
+    id: str
+    kind: str
+
+
+class Preview(BaseModel):
+    url: str
+    hls_url: str = Field(..., alias="hlsUrl")
+    artwork: ImageModel
+
+
+class Attributes(BaseModel):
+    genre_names: List[str] = Field(..., alias="genreNames")
+    release_date: str = Field(..., alias="releaseDate")
+    duration_in_millis: int = Field(..., alias="durationInMillis")
+    isrc: str
+    artwork: ImageModel
+    play_params: PlayParams = Field(..., alias="playParams")
+    url: str
+    has4_k: bool = Field(..., alias="has4K")
+    editorial_artwork: Dict[str, Any] = Field(..., alias="editorialArtwork")
+    has_hdr: bool = Field(..., alias="hasHDR")
+    name: str
+    previews: List[Preview]
+    artist_name: str = Field(..., alias="artistName")
+    content_rating: Optional[str] = Field(None, alias="contentRating")
+    album_name: Optional[str] = Field(None, alias="albumName")
+    track_number: Optional[int] = Field(None, alias="trackNumber")
+
+
+class TopMusicVideosView(BaseModel):
+    href: Optional[str] = None
+    attributes: Optional[AttributeName] = None
+    data: Optional[List[BaseDataModel[Attributes]]] = None

lib/ShazamIO/shazamio/schemas/artist/views/top_song.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from shazamio.schemas.artist.views.top_music import PlayParams
+from shazamio.schemas.attributes import AttributeName
+from shazamio.schemas.base import BaseDataModel
+from shazamio.schemas.photos import ImageModel
+from shazamio.schemas.urls import UrlDTO
+
+
+class AttributesTopSong(BaseModel):
+    has_time_synced_lyrics: bool = Field(..., alias="hasTimeSyncedLyrics")
+    album_name: Optional[str] = Field(None, alias="albumName")
+    genre_names: List = Field(..., alias="genreNames")
+    track_number: int = Field(..., alias="trackNumber")
+    release_date: str = Field(..., alias="releaseDate")
+    duration_in_millis: int = Field(..., alias="durationInMillis")
+    is_vocal_attenuation_allowed: bool = Field(..., alias="isVocalAttenuationAllowed")
+    is_mastered_for_itunes: bool = Field(..., alias="isMasteredForItunes")
+    isrc: str
+    artwork: ImageModel
+    composer_name: str = Field(..., alias="composerName")
+    audio_locale: str = Field(..., alias="audioLocale")
+    url: str
+    play_params: PlayParams = Field(..., alias="playParams")
+    disc_number: int = Field(..., alias="discNumber")
+    has_lyrics: bool = Field(..., alias="hasLyrics")
+    is_apple_digital_master: bool = Field(..., alias="isAppleDigitalMaster")
+    audio_traits: List[str] = Field(..., alias="audioTraits")
+    name: str
+    previews: List[UrlDTO] = Field([])
+    artist_name: str = Field(..., alias="artistName")
+    content_rating: Optional[str] = Field(None, alias="contentRating")
+
+
+class TopSong(BaseModel):
+    id: Optional[str] = None
+    type: Optional[str] = None
+    href: Optional[str] = None
+    attributes: Optional[AttributeName] = None
+    data: Optional[List[BaseDataModel[AttributesTopSong]]] = None

lib/ShazamIO/shazamio/schemas/artists.py

@@ -0,0 +1,100 @@
+from dataclasses import dataclass
+from dataclasses import field
+from typing import List
+from typing import Optional
+from typing import Union
+
+from pydantic import BaseModel
+from pydantic import Field
+
+from shazamio.schemas.artist.views.full_albums import FullAlbumsModel
+from shazamio.schemas.artist.views.last_release import LastReleaseModel
+from shazamio.schemas.artist.views.simular_artists import SimularArtist
+from shazamio.schemas.artist.views.top_music import TopMusicVideosView
+from shazamio.schemas.artist.views.top_song import TopSong
+from shazamio.schemas.attributes import ArtistAttribute
+from shazamio.schemas.enums import ArtistExtend
+from shazamio.schemas.enums import ArtistView
+from shazamio.schemas.errors import ErrorModel
+
+
+@dataclass
+class ArtistInfo:
+    name: str
+    verified: Optional[bool]
+    genres: Optional[List[str]] = field(default_factory=list)
+    alias: Optional[str] = None
+    genres_primary: Optional[str] = None
+    avatar: Optional[Union[dict, str]] = None
+    adam_id: Optional[int] = None
+    url: Optional[str] = ""
+
+    def __post_init__(self):
+        self.avatar = self.__optional_avatar()
+
+    def __optional_avatar(self) -> Optional[str]:
+        if self.avatar is None:
+            return None
+        elif "default" in self.avatar:
+            return self.avatar.get("default")
+        else:
+            return "".join(self.avatar)
+
+
+@dataclass
+class ArtistV2:
+    artist: ArtistInfo
+
+
+@dataclass
+class ArtistQuery:
+    views: List[ArtistView] = field(default_factory=list)
+    extend: List[ArtistExtend] = field(default_factory=list)
+
+
+@dataclass
+class ArtistAvatar:
+    width: int
+    height: int
+    url: str
+
+    @classmethod
+    def url_with_size(cls, height: int, width: int) -> str:
+        return cls.url.format(w=width, h=height)
+
+
+class AlbumRelationshipElement(BaseModel):
+    id: str
+    type: str
+    href: str
+
+
+class AlbumRelationship(BaseModel):
+    href: str
+    next: Optional[str] = None
+    data: List[AlbumRelationshipElement]
+
+
+class ArtistRelationships(BaseModel):
+    albums: AlbumRelationship
+
+
+class ArtistViews(BaseModel):
+    top_music_videos: Optional[TopMusicVideosView] = Field(None, alias="top-music-videos")
+    simular_artists: Optional[SimularArtist] = Field(None, alias="similar-artists")
+    latest_release: Optional[LastReleaseModel] = Field(None, alias="latest-release")
+    full_albums: Optional[FullAlbumsModel] = Field(None, alias="full-albums")
+    top_songs: Optional[TopSong] = Field(None, alias="top-songs")
+
+
+class ArtistV3(BaseModel):
+    id: str
+    type: str
+    attributes: ArtistAttribute
+    relationships: ArtistRelationships
+    views: ArtistViews
+
+
+class ArtistResponse(BaseModel):
+    errors: List[ErrorModel] = []
+    data: List[ArtistV3] = []

lib/ShazamIO/shazamio/schemas/attributes.py

@@ -0,0 +1,16 @@
+from typing import List
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Field
+
+
+class AttributeName(BaseModel):
+    title: str
+
+
+class ArtistAttribute(BaseModel):
+    genre_names: List[str] = Field([], alias="genreNames")
+    name: str
+    url: str
+    artist_bio: Optional[str] = Field(None, alias="artistBio")

lib/ShazamIO/shazamio/schemas/base.py

@@ -0,0 +1,25 @@
+from typing import Generic
+from typing import Optional
+from typing import TypeVar
+
+from pydantic import BaseModel
+from pydantic.generics import GenericModel
+
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class BaseIdTypeHref(BaseModel):
+    id: str
+    type: str
+    href: str
+
+
+class BaseDataModel(GenericModel, BaseModel, Generic[T]):
+    attributes: T
+
+
+class BaseHrefNextData(GenericModel, Generic[T]):
+    href: str
+    next: Optional[str] = None
+    data: T

lib/ShazamIO/shazamio/schemas/enums.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class ArtistExtend(str, Enum):
+    ARTIST_BIO = "artistBio"
+    BORN_OF_FORMED = "bornOrFormed"
+    EDITORIAL_ARTWORK = "editorialArtwork"
+    ORIGIN = "origin"
+
+
+class ArtistView(str, Enum):
+    FULL_ALBUMS = "full-albums"
+    FEATURED_ALBUMS = "featured-albums"
+    LATEST_RELEASE = "latest-release"
+    TOP_MUSIC_VIDEOS = "top-music-videos"
+    SIMULAR_ARTISTS = "similar-artists"
+    TOP_SONGS = "top-songs"
+    PLAYLISTS = "playlists"

lib/ShazamIO/shazamio/schemas/errors.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ErrorModel:
+    id: str
+    title: str
+    detail: str
+    status: str
+    code: str

lib/ShazamIO/shazamio/schemas/models.py

@@ -0,0 +1,201 @@
+from dataclasses import dataclass
+from dataclasses import field
+from typing import List
+from typing import Optional
+from typing import Union
+from urllib.parse import urlencode
+from urllib.parse import urlparse
+from urllib.parse import urlunparse
+from uuid import UUID
+
+
+@dataclass
+class ShareModel:
+    subject: str
+    text: str
+    href: str
+    image: str
+    twitter: str
+    html: str
+    snapchat: str
+
+
+@dataclass
+class ActionModel:
+    name: str
+    type: str
+    share: ShareModel
+    uri: str
+
+
+@dataclass
+class SongMetaPages:
+    image: str
+    caption: str
+
+
+@dataclass
+class SongMetadata:
+    title: str
+    text: str
+
+
+@dataclass
+class SongSection:
+    type: str
+    meta_pages: List[SongMetaPages]
+    tab_name: str
+    metadata: List[SongMetadata]
+
+
+@dataclass
+class BaseIdTypeModel:
+    type: str
+    id: str
+
+
+@dataclass
+class TopTracksModel:
+    url: str
+
+
+@dataclass
+class ArtistSection:
+    type: str
+    id: str
+    name: str
+    verified: bool
+    actions: List[BaseIdTypeModel]
+    tab_name: str
+    top_tracks: TopTracksModel
+
+
+class BeaconDataLyricsSection:
+    lyrics_id: str
+    provider_name: str
+    common_track_id: str
+
+
+@dataclass
+class LyricsSection:
+    type: str
+    text: List[str]
+    footer: str
+    tab_name: str
+    beacon_data: Optional[BeaconDataLyricsSection]
+
+
+@dataclass
+class VideoSection:
+    tab_name: str
+    youtube_url: str
+    type: str = "VIDEO"
+
+
+@dataclass
+class RelatedSection:
+    type: str
+    url: str
+    tab_name: str
+
+
+@dataclass
+class DimensionsModel:
+    width: int
+    height: int
+
+
+@dataclass
+class YoutubeImageModel:
+    dimensions: DimensionsModel
+    url: str
+
+
+@dataclass
+class MatchModel:
+    id: str
+    offset: float
+    time_skew: float
+    frequency_skew: float
+    channel: Optional[str] = field(default=None)
+
+
+@dataclass
+class LocationModel:
+    accuracy: float
+
+
+@dataclass
+class YoutubeData:
+    caption: str
+    image: YoutubeImageModel
+    actions: List[ActionModel]
+    uri: Optional[str] = None
+
+    def __post_init__(self):
+        self.uri = self.__get_youtube_uri()
+
+    def __get_youtube_uri(self):
+        if self.actions:
+            for action in self.actions:
+                if action.uri:
+                    return action.uri
+
+
+@dataclass
+class TrackInfo:
+    key: int
+    title: str
+    subtitle: str
+    artist_id: Optional[str] = field(default=None)
+    shazam_url: str = None
+    photo_url: Optional[str] = field(init=False, default=None)
+    spotify_uri_query: Optional[str] = None
+    apple_music_url: Optional[str] = None
+    ringtone: Optional[str] = None
+    spotify_url: Optional[str] = field(default=None)
+    spotify_uri: Optional[str] = field(default=None)
+    youtube_link: Optional[str] = None
+    sections: Optional[
+        List[
+            Union[
+                SongSection,
+                VideoSection,
+                RelatedSection,
+                ArtistSection,
+                LyricsSection,
+            ]
+        ]
+    ] = field(default_factory=list)
+
+    def __post_init__(self):
+        self.shazam_url = f"https://www.shazam.com/track/{self.artist_id}"
+        self.apple_music_url = self.__apple_music_url()
+        self.spotify_uri_query = self.__short_uri()
+        self.youtube_link = self.__youtube_link()
+
+    def __apple_music_url(self):
+        url_parse_list = list(urlparse(self.apple_music_url))
+        url_parse_list[4] = urlencode({}, doseq=True)
+        url_deleted_query = urlunparse(url_parse_list)
+        return url_deleted_query
+
+    def __short_uri(self):
+        if self.spotify_uri:
+            return self.spotify_uri.split("spotify:search:")[1]
+
+    def __youtube_link(self):
+        for i in self.sections:
+            if type(i) is VideoSection:
+                return i.youtube_url
+
+
+@dataclass
+class ResponseTrack:
+    tag_id: Optional[UUID]
+    retry_ms: Optional[int] = field(default=None)
+    location: Optional[LocationModel] = field(default=None)
+    matches: List[MatchModel] = field(default_factory=list)
+    timestamp: Optional[int] = field(default=None)
+    timezone: Optional[str] = field(default=None)
+    track: Optional[TrackInfo] = field(default=None)

lib/ShazamIO/shazamio/schemas/photos.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Field
+
+
+class ImageModel(BaseModel):
+    width: int
+    url: str
+    height: int
+    text_color3: Optional[str] = Field(None, alias="textColor3")
+    text_color2: Optional[str] = Field(None, alias="textColor2")
+    text_color4: Optional[str] = Field(None, alias="textColor4")
+    text_color1: Optional[str] = Field(None, alias="textColor1")
+    bg_color: Optional[str] = Field(None, alias="bgColor")
+    has_p3: bool = Field(..., alias="hasP3")

lib/ShazamIO/shazamio/schemas/urls.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class UrlDTO(BaseModel):
+    url: str