spotify-apimatic-sdk 1.0.0__py3-none-any.whl

spotifywebapi/models/album_restriction_object.py

@@ -0,0 +1,109 @@
+"""spotifywebapi.
+
+This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ).
+"""
+
+# ruff: noqa: E501
+from spotifywebapi.api_helper import APIHelper
+
+
+class AlbumRestrictionObject(object):
+    """Implementation of the 'AlbumRestrictionObject' model.
+
+    Attributes:
+        reason (ReasonEnum): The reason for the restriction. Albums may be restricted
+            if the content is not available in a given market, to the user's
+            subscription type, or when the user's account is set to not play explicit
+            content. Additional reasons may be added in the future.
+
+    """
+
+    # Create a mapping from Model property names to API property names
+    _names = {
+        "reason": "reason",
+    }
+
+    _optionals = [
+        "reason",
+    ]
+
+    def __init__(
+        self,
+        reason=APIHelper.SKIP):
+        """Initialize a AlbumRestrictionObject instance."""
+        # Initialize members of the class
+        if reason is not APIHelper.SKIP:
+            self.reason = reason
+
+    @classmethod
+    def from_dictionary(cls,
+                        dictionary):
+        """Create an instance of this model from a dictionary
+
+        Args:
+            dictionary (dictionary): A dictionary representation of the object
+            as obtained from the deserialization of the server's response. The
+            keys MUST match property names in the API description.
+
+        Returns:
+            object: An instance of this structure class.
+
+        """
+        if not isinstance(dictionary, dict) or dictionary is None:
+            return None
+
+        # Extract variables from the dictionary
+        reason =\
+            dictionary.get("reason")\
+            if dictionary.get("reason")\
+                else APIHelper.SKIP
+
+        # Return an object of this model
+        return cls(reason)
+
+    @classmethod
+    def validate(cls, dictionary):
+        """Validate dictionary against class required properties
+
+        Args:
+            dictionary (dictionary): A dictionary representation of the object
+            as obtained from the deserialization of the server's response. The
+            keys MUST match property names in the API description.
+
+        Returns:
+            boolean : if dictionary is valid contains required properties.
+
+        """
+        if isinstance(dictionary, cls):
+            return True
+
+        if not isinstance(dictionary, dict):
+            return False
+
+        return True
+
+    def __repr__(self):
+        """Return a unambiguous string representation."""
+        _reason=(
+            self.reason
+            if hasattr(self, "reason")
+            else None
+        )
+        return (
+            f"{self.__class__.__name__}("
+            f"reason={_reason!r}, "
+            f")"
+        )
+
+    def __str__(self):
+        """Return a human-readable string representation."""
+        _reason=(
+            self.reason
+            if hasattr(self, "reason")
+            else None
+        )
+        return (
+            f"{self.__class__.__name__}("
+            f"reason={_reason!s}, "
+            f")"
+        )

spotifywebapi/models/album_type_enum.py

@@ -0,0 +1,62 @@
+"""spotifywebapi.
+
+This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ).
+"""
+
+# ruff: noqa: E501
+
+class AlbumTypeEnum(object):
+    """Implementation of the 'AlbumType' enum.
+
+    The type of the album.
+
+    Attributes:
+        ALBUM: The enum member of type str.
+        SINGLE: The enum member of type str.
+        COMPILATION: The enum member of type str.
+
+    """
+
+    _all_values = ["album", "single", "compilation"]
+    ALBUM = "album"
+
+    SINGLE = "single"
+
+    COMPILATION = "compilation"
+
+    @classmethod
+    def validate(cls, value):
+        """Validate value contains in enum
+
+        Args:
+            value: the value to be validated
+
+        Returns:
+            boolean : if value is valid enum values.
+
+        """
+        return value in cls._all_values
+
+    @classmethod
+    def from_value(cls, value, default=None):
+        """Return the matching enum value for the given input."""
+        if value is None:
+            return default
+
+        # If numeric and matches directly
+        if isinstance(value, int):
+            for name, val in cls.__dict__.items():
+                if not name.startswith("_") and val == value:
+                    return val
+
+        # If string, perform case-insensitive match
+        if isinstance(value, str):
+            value_lower = value.lower()
+            for name, val in cls.__dict__.items():
+                if not name.startswith("_") and (
+                    name.lower() == value_lower or str(val).lower() == value_lower
+                ):
+                    return val
+
+        # Fallback to default
+        return default

spotifywebapi/models/artist_discography_album_object.py

@@ -0,0 +1,298 @@
+"""spotifywebapi.
+
+This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ).
+"""
+
+# ruff: noqa: E501
+from spotifywebapi.api_helper import APIHelper
+from spotifywebapi.models.album_restriction_object import (
+    AlbumRestrictionObject,
+)
+from spotifywebapi.models.external_url_object import (
+    ExternalUrlObject,
+)
+from spotifywebapi.models.image_object import (
+    ImageObject,
+)
+from spotifywebapi.models.simplified_artist_object import (
+    SimplifiedArtistObject,
+)
+
+
+class ArtistDiscographyAlbumObject(object):
+    """Implementation of the 'ArtistDiscographyAlbumObject' model.
+
+    Attributes:
+        album_type (AlbumTypeEnum): The type of the album.
+        total_tracks (int): The number of tracks in the album.
+        available_markets (List[str]): The markets in which the album is available:
+            [ISO 3166-1 alpha-2 country
+            codes](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). _**NOTE**: an
+            album is considered available in a market when at least 1 of its tracks
+            is available in that market._
+        external_urls (ExternalUrlObject): Known external URLs for this album.
+        href (str): A link to the Web API endpoint providing full details of the
+            album.
+        id (str): The [Spotify ID](/documentation/web-api/concepts/spotify-uris-ids)
+            for the album.
+        images (List[ImageObject]): The cover art for the album in various sizes,
+            widest first.
+        name (str): The name of the album. In case of an album takedown, the value
+            may be an empty string.
+        release_date (str): The date the album was first released.
+        release_date_precision (ReleaseDatePrecisionEnum): The precision with which
+            `release_date` value is known.
+        restrictions (AlbumRestrictionObject): Included in the response when a
+            content restriction is applied.
+        mtype (Type2Enum): The object type.
+        uri (str): The [Spotify
+            URI](/documentation/web-api/concepts/spotify-uris-ids) for the album.
+        artists (List[SimplifiedArtistObject]): The artists of the album. Each artist
+            object includes a link in `href` to more detailed information about the
+            artist.
+        album_group (AlbumGroupEnum): This field describes the relationship between
+            the artist and the album.
+
+    """
+
+    # Create a mapping from Model property names to API property names
+    _names = {
+        "album_type": "album_type",
+        "total_tracks": "total_tracks",
+        "available_markets": "available_markets",
+        "external_urls": "external_urls",
+        "href": "href",
+        "id": "id",
+        "images": "images",
+        "name": "name",
+        "release_date": "release_date",
+        "release_date_precision": "release_date_precision",
+        "mtype": "type",
+        "uri": "uri",
+        "artists": "artists",
+        "album_group": "album_group",
+        "restrictions": "restrictions",
+    }
+
+    _optionals = [
+        "restrictions",
+    ]
+
+    def __init__(
+        self,
+        album_type=None,
+        total_tracks=None,
+        available_markets=None,
+        external_urls=None,
+        href=None,
+        id=None,
+        images=None,
+        name=None,
+        release_date=None,
+        release_date_precision=None,
+        mtype=None,
+        uri=None,
+        artists=None,
+        album_group=None,
+        restrictions=APIHelper.SKIP):
+        """Initialize a ArtistDiscographyAlbumObject instance."""
+        # Initialize members of the class
+        self.album_type = album_type
+        self.total_tracks = total_tracks
+        self.available_markets = available_markets
+        self.external_urls = external_urls
+        self.href = href
+        self.id = id
+        self.images = images
+        self.name = name
+        self.release_date = release_date
+        self.release_date_precision = release_date_precision
+        if restrictions is not APIHelper.SKIP:
+            self.restrictions = restrictions
+        self.mtype = mtype
+        self.uri = uri
+        self.artists = artists
+        self.album_group = album_group
+
+    @classmethod
+    def from_dictionary(cls,
+                        dictionary):
+        """Create an instance of this model from a dictionary
+
+        Args:
+            dictionary (dictionary): A dictionary representation of the object
+            as obtained from the deserialization of the server's response. The
+            keys MUST match property names in the API description.
+
+        Returns:
+            object: An instance of this structure class.
+
+        """
+        if not isinstance(dictionary, dict) or dictionary is None:
+            return None
+
+        # Extract variables from the dictionary
+        album_type =\
+            dictionary.get("album_type")\
+            if dictionary.get("album_type")\
+                else None
+        total_tracks =\
+            dictionary.get("total_tracks")\
+            if dictionary.get("total_tracks")\
+                else None
+        available_markets =\
+            dictionary.get("available_markets")\
+            if dictionary.get("available_markets")\
+                else None
+        external_urls =\
+            ExternalUrlObject.from_dictionary(
+                dictionary.get("external_urls"))\
+                if dictionary.get("external_urls") else None
+        href =\
+            dictionary.get("href")\
+            if dictionary.get("href")\
+                else None
+        id =\
+            dictionary.get("id")\
+            if dictionary.get("id")\
+                else None
+        images = None
+        if dictionary.get("images") is not None:
+            images = [
+                ImageObject.from_dictionary(x)
+                    for x in dictionary.get("images")
+            ]
+        name =\
+            dictionary.get("name")\
+            if dictionary.get("name")\
+                else None
+        release_date =\
+            dictionary.get("release_date")\
+            if dictionary.get("release_date")\
+                else None
+        release_date_precision =\
+            dictionary.get("release_date_precision")\
+            if dictionary.get("release_date_precision")\
+                else None
+        mtype =\
+            dictionary.get("type")\
+            if dictionary.get("type")\
+                else None
+        uri =\
+            dictionary.get("uri")\
+            if dictionary.get("uri")\
+                else None
+        artists = None
+        if dictionary.get("artists") is not None:
+            artists = [
+                SimplifiedArtistObject.from_dictionary(x)
+                    for x in dictionary.get("artists")
+            ]
+        album_group =\
+            dictionary.get("album_group")\
+            if dictionary.get("album_group")\
+                else None
+        restrictions =\
+            AlbumRestrictionObject.from_dictionary(
+                dictionary.get("restrictions"))\
+                if "restrictions" in dictionary.keys()\
+                else APIHelper.SKIP
+
+        # Return an object of this model
+        return cls(album_type,
+                   total_tracks,
+                   available_markets,
+                   external_urls,
+                   href,
+                   id,
+                   images,
+                   name,
+                   release_date,
+                   release_date_precision,
+                   mtype,
+                   uri,
+                   artists,
+                   album_group,
+                   restrictions)
+
+    def __repr__(self):
+        """Return a unambiguous string representation."""
+        _album_type=self.album_type
+        _total_tracks=self.total_tracks
+        _available_markets=self.available_markets
+        _external_urls=self.external_urls
+        _href=self.href
+        _id=self.id
+        _images=self.images
+        _name=self.name
+        _release_date=self.release_date
+        _release_date_precision=self.release_date_precision
+        _restrictions=(
+            self.restrictions
+            if hasattr(self, "restrictions")
+            else None
+        )
+        _mtype=self.mtype
+        _uri=self.uri
+        _artists=self.artists
+        _album_group=self.album_group
+        return (
+            f"{self.__class__.__name__}("
+            f"album_type={_album_type!r}, "
+            f"total_tracks={_total_tracks!r}, "
+            f"available_markets={_available_markets!r}, "
+            f"external_urls={_external_urls!r}, "
+            f"href={_href!r}, "
+            f"id={_id!r}, "
+            f"images={_images!r}, "
+            f"name={_name!r}, "
+            f"release_date={_release_date!r}, "
+            f"release_date_precision={_release_date_precision!r}, "
+            f"restrictions={_restrictions!r}, "
+            f"mtype={_mtype!r}, "
+            f"uri={_uri!r}, "
+            f"artists={_artists!r}, "
+            f"album_group={_album_group!r}, "
+            f")"
+        )
+
+    def __str__(self):
+        """Return a human-readable string representation."""
+        _album_type=self.album_type
+        _total_tracks=self.total_tracks
+        _available_markets=self.available_markets
+        _external_urls=self.external_urls
+        _href=self.href
+        _id=self.id
+        _images=self.images
+        _name=self.name
+        _release_date=self.release_date
+        _release_date_precision=self.release_date_precision
+        _restrictions=(
+            self.restrictions
+            if hasattr(self, "restrictions")
+            else None
+        )
+        _mtype=self.mtype
+        _uri=self.uri
+        _artists=self.artists
+        _album_group=self.album_group
+        return (
+            f"{self.__class__.__name__}("
+            f"album_type={_album_type!s}, "
+            f"total_tracks={_total_tracks!s}, "
+            f"available_markets={_available_markets!s}, "
+            f"external_urls={_external_urls!s}, "
+            f"href={_href!s}, "
+            f"id={_id!s}, "
+            f"images={_images!s}, "
+            f"name={_name!s}, "
+            f"release_date={_release_date!s}, "
+            f"release_date_precision={_release_date_precision!s}, "
+            f"restrictions={_restrictions!s}, "
+            f"mtype={_mtype!s}, "
+            f"uri={_uri!s}, "
+            f"artists={_artists!s}, "
+            f"album_group={_album_group!s}, "
+            f")"
+        )