spotifywebapiPython 1.0.242__py3-none-any.whl

spotifywebapipython/models/__init__.py

@@ -0,0 +1,121 @@
+# import all classes from the namespace.
+from .album import Album, AlbumSimplified
+from .albumpagesaved import AlbumPageSaved, AlbumSaved
+from .albumpagesimplified import AlbumPageSimplified
+from .artist import Artist, ArtistSimplified
+from .artistinfo import ArtistInfo, ArtistInfoTourEvent
+from .artistpage import ArtistPage
+from .audiobook import Audiobook, AudiobookSimplified
+from .audiobookpagesimplified import AudiobookPageSimplified
+from .audiofeatures import AudioFeatures
+from .author import Author
+from .category import Category
+from .categorypage import CategoryPage
+from .chapter import Chapter, ChapterSimplified
+from .chapterpagesimplified import ChapterPageSimplified
+from .context import Context
+from .copyright import Copyright
+from .device import Device
+from .episode import Episode, EpisodeSimplified
+from .episodepagesaved import EpisodePageSaved, EpisodeSaved
+from .episodepagesimplified import EpisodePageSimplified
+from .explicitcontent import ExplicitContent
+from .externalids import ExternalIds
+from .externalurls import ExternalUrls
+from .followers import Followers
+from .imageobject import ImageObject
+from .imagevibrantcolors import ImageVibrantColors
+from .linkedfrom import LinkedFrom
+from .narrator import Narrator
+from .owner import Owner
+from .pageobject import PageObject
+from .playeractions import PlayerActions
+from .playerlastplayedinfo import PlayerLastPlayedInfo
+from .playerplaystate import PlayerPlayState
+from .playerqueueinfo import PlayerQueueInfo
+from .playhistory import PlayHistory
+from .playhistorypage import PlayHistoryPage
+from .playlist import Playlist, PlaylistSimplified
+from .playlistpage import PlaylistPage
+from .playlistpagesimplified import PlaylistPageSimplified
+from .playlisttrack import PlaylistTrack
+from .playlisttracksummary import PlaylistTrackSummary
+from .recommendationseed import RecommendationSeed
+from .restrictions import Restrictions
+from .resumepoint import ResumePoint
+from .searchresponse import SearchResponse
+from .searchresultbase import SearchResultBase
+from .show import Show, ShowSimplified
+from .showpagesaved import ShowPageSaved, ShowSaved
+from .showpagesimplified import ShowPageSimplified
+from .spotifyconnectdevices import SpotifyConnectDevices, SpotifyConnectDevice
+from .track import Track, TrackSimplified
+from .trackpage import TrackPage
+from .trackpagesaved import TrackPageSaved, TrackSaved
+from .trackpagesimplified import TrackPageSimplified
+from .trackrecommendations import TrackRecommendations
+from .userprofile import UserProfile, UserProfileSimplified
+from .zeroconfdiscoveryresult import ZeroconfDiscoveryResult
+from .zeroconfproperty import ZeroconfProperty
+
+# all classes to import when "import *" is specified.
+__all__ = [
+    'Album','AlbumSimplified',
+    'AlbumPageSaved','AlbumSaved',
+    'AlbumPageSimplified',
+    'Artist','ArtistSimplified',
+    'ArtistInfo', 'ArtistInfoTourEvent',
+    'ArtistPage',
+    'Audiobook','AudiobookSimplified',
+    'AudiobookPageSimplified',
+    'AudioFeatures',
+    'Author',
+    'Category',
+    'CategoryPage',
+    'Chapter','ChapterSimplified',
+    'ChapterPageSimplified',
+    'Context',
+    'Copyright',
+    'Device',
+    'Episode','EpisodeSimplified',
+    'EpisodePageSaved','EpisodeSaved',
+    'EpisodePageSimplified',
+    'ExplicitContent',
+    'ExternalIds',
+    'ExternalUrls',
+    'Followers',
+    'ImageObject',
+    'ImageVibrantColors',
+    'LinkedFrom',
+    'Narrator',
+    'Owner',
+    'PageObject',
+    'PlayerActions',
+    'PlayerLastPlayedInfo',
+    'PlayerPlayState',
+    'PlayerQueueInfo',
+    'PlayHistory',
+    'PlayHistoryPage',
+    'Playlist','PlaylistSimplified',
+    'PlaylistPage',
+    'PlaylistPageSimplified',
+    'PlaylistTrack',
+    'PlaylistTrackSummary',
+    'RecommendationSeed',
+    'Restrictions',
+    'ResumePoint',
+    'SearchResponse',
+    'SearchResultBase',
+    'Show','ShowSimplified',
+    'ShowPageSaved','ShowSaved',
+    'ShowPageSimplified',
+    'SpotifyConnectDevices', 'SpotifyConnectDevice',
+    'Track','TrackSimplified',
+    'TrackPage',
+    'TrackPageSaved','TrackSaved',
+    'TrackPageSimplified',
+    'TrackRecommendations',
+    'UserProfile','UserProfileSimplified',
+    'ZeroconfDiscoveryResult',
+    'ZeroconfProperty',
+]

spotifywebapipython/models/album.py

@@ -0,0 +1,170 @@
+# external package imports.
+
+# our package imports.
+from ..sautils import export
+from .albumsimplified import AlbumSimplified
+from .copyright import Copyright
+from .externalids import ExternalIds
+from .externalurls import ExternalUrls
+from .trackpagesimplified import TrackPageSimplified
+
+@export
+class Album(AlbumSimplified):
+    """
+    Spotify Web API Album object.
+    """
+
+    def __init__(self, root:dict=None) -> None:
+        """
+        Initializes a new instance of the class.
+        
+        Args:
+            root (dict):
+                Spotify Web API JSON response in dictionary format, used to load object
+                attributes; otherwise, None to not load attributes.
+        """
+        # initialize base class.
+        super().__init__(root=root)
+        
+        # initialize storage.
+        self._Copyrights:list[Copyright] = []
+        self._ExternalIds:ExternalIds = None
+        self._Genres:list[str] = []
+        self._Label:str = None
+        self._Popularity:int = None
+        self._Tracks:TrackPageSimplified = None
+        
+        if (root is None):
+
+            pass
+        
+        else:
+
+            self._Label = root.get('label', None)
+            self._Popularity = root.get('popularity', None)
+
+            # process all collections and objects.
+            items:list = root.get('copyrights',None)
+            if items is not None:
+                for item in items:
+                    self._Copyrights.append(Copyright(root=item))
+
+            item:dict = root.get('external_ids',None)
+            if item is not None:
+                self._ExternalIds = ExternalIds(root=item)
+
+            items:list[str] = root.get('genres',None)
+            if items is not None:
+                for item in items:
+                    self._Genres.append(item)
+        
+            item:dict = root.get('tracks',None)
+            if item is not None:
+                self._Tracks = TrackPageSimplified(root=item)
+
+        
+    def __repr__(self) -> str:
+        return self.ToString()
+
+
+    def __str__(self) -> str:
+        return self.ToString()
+
+
+    @property
+    def Copyrights(self) -> list[Copyright]:
+        """ 
+        The copyright statements of the album.
+        """
+        return self._Copyrights
+    
+
+    @property
+    def ExternalIds(self) -> ExternalUrls:
+        """ 
+        Known external IDs for the album.
+        """
+        return self._ExternalIds
+    
+
+    @property
+    def Genres(self) -> list[str]:
+        """ 
+        A list of the genres the album is associated with. If not yet classified, the array is empty.  
+        
+        Example: `["Egg punk","Noise rock"]`
+        """
+        return self._Genres
+
+
+    @property
+    def Label(self) -> str:
+        """ 
+        The label associated with the album.
+        """
+        return self._Label
+
+
+    @property
+    def Popularity(self) -> int:
+        """ 
+        The popularity of the album.  
+        
+        The value will be between 0 and 100, with 100 being the most popular.
+        """
+        return self._Popularity
+
+
+    @property
+    def Tracks(self) -> TrackPageSimplified:
+        """ 
+        The tracks of the album.
+        
+        This is a `TrackPageSimplified` object, meaning only 50 tracks max are listed per request.
+        """
+        return self._Tracks
+
+
+    def ToDictionary(self) -> dict:
+        """
+        Returns a dictionary representation of the class.
+        """
+        # get base class result.
+        resultBase:dict = super().ToDictionary()
+
+        externalIds:dict = {}
+        if self._ExternalIds is not None:
+            externalIds = self._ExternalIds.ToDictionary()
+
+        result:dict = \
+        {
+            'copyrights': [ item.ToDictionary() for item in self._Copyrights ],
+            'external_ids': externalIds,
+            'genres': [ item for item in self._Genres ],
+            'label': self._Label,
+            'popularity': self._Popularity,
+        }
+        
+        # only add the tracks key if data is present.
+        if self._Tracks is not None:
+            tracks:dict = self._Tracks.ToDictionary()
+            result['tracks'] = tracks
+       
+        # combine base class results with these results.
+        resultBase.update(result)
+        
+        # return a sorted dictionary.
+        return dict(sorted(resultBase.items()))
+        
+
+    def ToString(self) -> str:
+        """
+        Returns a displayable string representation of the class.
+        """
+        msg:str = 'Album: %s' % super().ToString(False)
+        #if self._Copyrights is not None: msg = '%s\n %s' % (msg, str(self._Copyrights))
+        #if self._ExternalIds is not None: msg = '%s\n %s' % (msg, str(self._ExternalIds))
+        if self._Genres is not None: msg = '%s\n Genres Count=%s' % (msg, str(len(self._Genres)))
+        if self._Label is not None: msg = '%s\n Label="%s"' % (msg, str(self._Label))
+        if self._Popularity is not None: msg = '%s\n Popularity="%s"' % (msg, str(self._Popularity))
+        return msg 

spotifywebapipython/models/albumpagesaved.py

@@ -0,0 +1,85 @@
+# external package imports.
+
+# our package imports.
+from ..sautils import export
+from .album import Album
+from .albumsaved import AlbumSaved
+from .pageobject import PageObject
+
+@export
+class AlbumPageSaved(PageObject):
+    """
+    Spotify Web API AlbumPageSaved object.
+    
+    This allows for multiple pages of `AlbumSaved` objects to be navigated.
+    """
+
+    def __init__(self, root:dict=None) -> None:
+        """
+        Initializes a new instance of the class.
+        
+        Args:
+            root (dict):
+                Spotify Web API JSON response in dictionary format, used to load object
+                attributes; otherwise, None to not load attributes.
+        """
+        # initialize base class.
+        super().__init__(root=root)
+        
+        # initialize storage.
+        self._Items:list[AlbumSaved] = []
+        
+        if (root is None):
+
+            pass
+        
+        else:
+
+            # process all collections and objects.
+            items:list = root.get('items',None)
+            if items is not None:
+                for item in items:
+                    if item is not None:
+                        self._Items.append(AlbumSaved(root=item))
+
+        
+    def __repr__(self) -> str:
+        return self.ToString()
+
+
+    def __str__(self) -> str:
+        return self.ToString()
+
+
+    @property
+    def Items(self) -> list[AlbumSaved]:
+        """ 
+        Array of `AlbumSaved` objects.
+        """
+        return self._Items
+    
+
+    def GetAlbums(self) -> list[Album]:
+        """ 
+        Gets a list of all albums contained in the underlying `Items` list.
+        
+        This is a convenience method so one does not have to loop through the `Items`
+        array of AlbumSaved objects to get the list of albums.
+        """
+        result:list[Album] = []
+        item:AlbumSaved
+        for item in self._Items:
+            result.append(item.Album)
+        return result
+    
+
+    def ToString(self, includeItems:bool=False) -> str:
+        """
+        Returns a displayable string representation of the class.
+        
+        Args:
+            includeItems (bool):
+                True to include the Items collection of objects; otherwise, False
+                to only return base properties.
+        """
+        return 'AlbumPageSaved: %s' % super().ToString(includeItems)

spotifywebapipython/models/albumpagesimplified.py

@@ -0,0 +1,88 @@
+# external package imports.
+
+# our package imports.
+from ..sautils import export
+from .albumsimplified import AlbumSimplified
+from .pageobject import PageObject
+
+@export
+class AlbumPageSimplified(PageObject):
+    """
+    Spotify Web API SimplifiedAlbumPage object.
+    
+    This allows for multiple pages of `AlbumSimplified` objects to be navigated.
+    """
+
+    def __init__(self, root:dict=None) -> None:
+        """
+        Initializes a new instance of the class.
+        
+        Args:
+            root (dict):
+                Spotify Web API JSON response in dictionary format, used to load object
+                attributes; otherwise, None to not load attributes.
+        """
+        # initialize base class.
+        super().__init__(root=root)
+        
+        # initialize storage.
+        self._Items:list[AlbumSimplified] = []
+        
+        if (root is None):
+
+            self._Total = 0
+        
+        else:
+
+            # process all collections and objects.
+            items:list = root.get('items',None)
+            if items is not None:
+                for item in items:
+                    if item is not None:
+                        self._Items.append(AlbumSimplified(root=item))
+
+        
+    def __repr__(self) -> str:
+        return self.ToString()
+
+
+    def __str__(self) -> str:
+        return self.ToString()
+
+
+    @property
+    def Items(self) -> list[AlbumSimplified]:
+        """ 
+        Array of `AlbumSimplified` objects.
+        """
+        return self._Items
+    
+
+    def ContainsId(self, itemId:str=False) -> bool:
+        """
+        Checks the `Items` collection to see if an item already exists with the
+        specified Id value.
+        
+        Returns True if the itemId exists in the collection; otherwise, False.
+        """
+        result:bool = False
+        
+        item:AlbumSimplified
+        for item in self._Items:
+            if item.Id == itemId:
+                result = True
+                break
+            
+        return result
+        
+
+    def ToString(self, includeItems:bool=False) -> str:
+        """
+        Returns a displayable string representation of the class.
+        
+        Args:
+            includeItems (bool):
+                True to include the Items collection of objects; otherwise, False
+                to only return base properties.
+        """
+        return 'AlbumPageSimplified: %s' % super().ToString(includeItems)

spotifywebapipython/models/albumsaved.py

@@ -0,0 +1,102 @@
+# external package imports.
+
+# our package imports.
+from ..sautils import export
+from .album import Album
+
+@export
+class AlbumSaved:
+    """
+    Spotify Web API SavedAlbum object.
+    """
+
+    def __init__(self, root:dict=None) -> None:
+        """
+        Initializes a new instance of the class.
+        
+        Args:
+            root (dict):
+                Spotify Web API JSON response in dictionary format, used to load object
+                attributes; otherwise, None to not load attributes.
+        """
+        self._Album:Album = None
+        self._AddedAt:str = None
+        
+        if (root is None):
+
+            pass
+        
+        else:
+
+            self._AddedAt = root.get('added_at', None)
+
+            # process all collections and objects.
+            item:dict = root.get('album',None)
+            if item is not None:
+                self._Album = Album(root=item)
+
+        
+    def __repr__(self) -> str:
+        return self.ToString()
+
+
+    def __str__(self) -> str:
+        return self.ToString()
+
+
+    @property
+    def AddedAt(self) -> str:
+        """ 
+        The date and time the album was saved. 
+        
+        Timestamps are returned in ISO 8601 format as Coordinated Universal Time (UTC) with a zero 
+        offset: YYYY-MM-DDTHH:MM:SSZ. If the time is imprecise (for example, the date/time of an 
+        album release), an additional field indicates the precision; see for example, release_date 
+        in an album object.
+        """
+        return self._AddedAt
+
+
+    @property
+    def Album(self) -> Album:
+        """ 
+        Information about the album.
+        """
+        return self._Album
+    
+
+    def ToDictionary(self) -> dict:
+        """
+        Returns a dictionary representation of the class.
+        """
+        album:dict = {}
+        if self._Album is not None:
+            album = self._Album.ToDictionary()
+
+        result:dict = \
+        {
+            'added_at': self._AddedAt,
+            'album': album
+        }
+        return result
+        
+
+    def ToString(self, includeItems:bool=False) -> str:
+        """
+        Returns a displayable string representation of the class.
+
+        Args:
+            includeItems (bool):
+                True to include the Items collection of objects; otherwise, False
+                to only return base properties.
+        """
+        msg:str = 'AlbumSaved:'
+        if self._AddedAt is not None: msg = '%s\n AddedAt="%s"' % (msg, str(self._AddedAt))
+        
+        if self._Album is not None:
+            if (includeItems):
+                msg = '%s\n %s' % (msg, str(self._Album))
+            else:
+                msg = '%s, Album Name="%s"' % (msg, self._Album.Name)
+            
+        return msg