from reprlib import repr as limitedRepr from typing import List class ItunesLookupResp: class _results: _types_map = { "appletvScreenshotUrls": {"type": list, "subtype": float}, "screenshotUrls": {"type": list, "subtype": str}, "ipadScreenshotUrls": {"type": list, "subtype": str}, "artworkUrl60": {"type": str, "subtype": None}, "artworkUrl512": {"type": str, "subtype": None}, "artworkUrl100": {"type": str, "subtype": None}, "artistViewUrl": {"type": str, "subtype": None}, "supportedDevices": {"type": list, "subtype": str}, "advisories": {"type": list, "subtype": float}, "isGameCenterEnabled": {"type": bool, "subtype": None}, "kind": {"type": str, "subtype": None}, "features": {"type": list, "subtype": str}, "minimumOsVersion": {"type": str, "subtype": None}, "trackCensoredName": {"type": str, "subtype": None}, "languageCodesISO2A": {"type": list, "subtype": str}, "fileSizeBytes": {"type": str, "subtype": None}, "formattedPrice": {"type": str, "subtype": None}, "contentAdvisoryRating": {"type": str, "subtype": None}, "averageUserRatingForCurrentVersion": {"type": float, "subtype": None}, "userRatingCountForCurrentVersion": {"type": int, "subtype": None}, "averageUserRating": {"type": float, "subtype": None}, "trackViewUrl": {"type": str, "subtype": None}, "trackContentRating": {"type": str, "subtype": None}, "releaseDate": {"type": str, "subtype": None}, "genreIds": {"type": list, "subtype": str}, "primaryGenreName": {"type": str, "subtype": None}, "trackId": {"type": int, "subtype": None}, "trackName": {"type": str, "subtype": None}, "sellerName": {"type": str, "subtype": None}, "isVppDeviceBasedLicensingEnabled": {"type": bool, "subtype": None}, "currentVersionReleaseDate": {"type": str, "subtype": None}, "releaseNotes": {"type": str, "subtype": None}, "primaryGenreId": {"type": int, "subtype": None}, "currency": {"type": str, "subtype": None}, "version": {"type": str, "subtype": None}, "wrapperType": {"type": str, "subtype": None}, "artistId": {"type": int, "subtype": None}, "artistName": {"type": str, "subtype": None}, "genres": {"type": list, "subtype": str}, "price": {"type": float, "subtype": None}, "description": {"type": str, "subtype": None}, "bundleId": {"type": str, "subtype": None}, "userRatingCount": {"type": int, "subtype": None}, } _formats_map = {} _validations_map = { "appletvScreenshotUrls": { "required": True, }, "screenshotUrls": { "required": True, }, "ipadScreenshotUrls": { "required": True, }, "artworkUrl60": { "required": True, }, "artworkUrl512": { "required": True, }, "artworkUrl100": { "required": True, }, "artistViewUrl": { "required": True, }, "supportedDevices": { "required": True, }, "advisories": { "required": True, }, "isGameCenterEnabled": { "required": True, }, "kind": { "required": True, }, "features": { "required": True, }, "minimumOsVersion": { "required": True, }, "trackCensoredName": { "required": True, }, "languageCodesISO2A": { "required": True, }, "fileSizeBytes": { "required": True, }, "formattedPrice": { "required": True, }, "contentAdvisoryRating": { "required": True, }, "averageUserRatingForCurrentVersion": { "required": True, }, "userRatingCountForCurrentVersion": { "required": True, }, "averageUserRating": { "required": True, }, "trackViewUrl": { "required": True, }, "trackContentRating": { "required": True, }, "releaseDate": { "required": True, }, "genreIds": { "required": True, }, "primaryGenreName": { "required": True, }, "trackId": { "required": True, }, "trackName": { "required": True, }, "sellerName": { "required": True, }, "isVppDeviceBasedLicensingEnabled": { "required": True, }, "currentVersionReleaseDate": { "required": True, }, "releaseNotes": { "required": True, }, "primaryGenreId": { "required": True, }, "currency": { "required": True, }, "version": { "required": True, }, "wrapperType": { "required": True, }, "artistId": { "required": True, }, "artistName": { "required": True, }, "genres": { "required": True, }, "price": { "required": True, }, "description": { "required": True, }, "bundleId": { "required": True, }, "userRatingCount": { "required": True, }, } def __init__( self, appletvScreenshotUrls: List[float] = None, screenshotUrls: List[str] = None, ipadScreenshotUrls: List[str] = None, artworkUrl60: str = None, artworkUrl512: str = None, artworkUrl100: str = None, artistViewUrl: str = None, supportedDevices: List[str] = None, advisories: List[float] = None, isGameCenterEnabled: bool = None, kind: str = None, features: List[str] = None, minimumOsVersion: str = None, trackCensoredName: str = None, languageCodesISO2A: List[str] = None, fileSizeBytes: str = None, formattedPrice: str = None, contentAdvisoryRating: str = None, averageUserRatingForCurrentVersion: float = None, userRatingCountForCurrentVersion: int = None, averageUserRating: float = None, trackViewUrl: str = None, trackContentRating: str = None, releaseDate: str = None, genreIds: List[str] = None, primaryGenreName: str = None, trackId: int = None, trackName: str = None, sellerName: str = None, isVppDeviceBasedLicensingEnabled: bool = None, currentVersionReleaseDate: str = None, releaseNotes: str = None, primaryGenreId: int = None, currency: str = None, version: str = None, wrapperType: str = None, artistId: int = None, artistName: str = None, genres: List[str] = None, price: float = None, description: str = None, bundleId: str = None, userRatingCount: int = None, ): pass self.__appletvScreenshotUrls = appletvScreenshotUrls self.__screenshotUrls = screenshotUrls self.__ipadScreenshotUrls = ipadScreenshotUrls self.__artworkUrl60 = artworkUrl60 self.__artworkUrl512 = artworkUrl512 self.__artworkUrl100 = artworkUrl100 self.__artistViewUrl = artistViewUrl self.__supportedDevices = supportedDevices self.__advisories = advisories self.__isGameCenterEnabled = isGameCenterEnabled self.__kind = kind self.__features = features self.__minimumOsVersion = minimumOsVersion self.__trackCensoredName = trackCensoredName self.__languageCodesISO2A = languageCodesISO2A self.__fileSizeBytes = fileSizeBytes self.__formattedPrice = formattedPrice self.__contentAdvisoryRating = contentAdvisoryRating self.__averageUserRatingForCurrentVersion = ( averageUserRatingForCurrentVersion ) self.__userRatingCountForCurrentVersion = userRatingCountForCurrentVersion self.__averageUserRating = averageUserRating self.__trackViewUrl = trackViewUrl self.__trackContentRating = trackContentRating self.__releaseDate = releaseDate self.__genreIds = genreIds self.__primaryGenreName = primaryGenreName self.__trackId = trackId self.__trackName = trackName self.__sellerName = sellerName self.__isVppDeviceBasedLicensingEnabled = isVppDeviceBasedLicensingEnabled self.__currentVersionReleaseDate = currentVersionReleaseDate self.__releaseNotes = releaseNotes self.__primaryGenreId = primaryGenreId self.__currency = currency self.__version = version self.__wrapperType = wrapperType self.__artistId = artistId self.__artistName = artistName self.__genres = genres self.__price = price self.__description = description self.__bundleId = bundleId self.__userRatingCount = userRatingCount def _get_appletvScreenshotUrls(self): return self.__appletvScreenshotUrls def _set_appletvScreenshotUrls(self, value): if not isinstance(value, list): raise TypeError("appletvScreenshotUrls must be list") if not all(isinstance(i, float) for i in value): raise TypeError("appletvScreenshotUrls list values must be float") self.__appletvScreenshotUrls = value appletvScreenshotUrls = property( _get_appletvScreenshotUrls, _set_appletvScreenshotUrls ) def _get_screenshotUrls(self): return self.__screenshotUrls def _set_screenshotUrls(self, value): if not isinstance(value, list): raise TypeError("screenshotUrls must be list") if not all(isinstance(i, str) for i in value): raise TypeError("screenshotUrls list values must be str") self.__screenshotUrls = value screenshotUrls = property(_get_screenshotUrls, _set_screenshotUrls) def _get_ipadScreenshotUrls(self): return self.__ipadScreenshotUrls def _set_ipadScreenshotUrls(self, value): if not isinstance(value, list): raise TypeError("ipadScreenshotUrls must be list") if not all(isinstance(i, str) for i in value): raise TypeError("ipadScreenshotUrls list values must be str") self.__ipadScreenshotUrls = value ipadScreenshotUrls = property(_get_ipadScreenshotUrls, _set_ipadScreenshotUrls) def _get_artworkUrl60(self): return self.__artworkUrl60 def _set_artworkUrl60(self, value): if not isinstance(value, str): raise TypeError("artworkUrl60 must be str") self.__artworkUrl60 = value artworkUrl60 = property(_get_artworkUrl60, _set_artworkUrl60) def _get_artworkUrl512(self): return self.__artworkUrl512 def _set_artworkUrl512(self, value): if not isinstance(value, str): raise TypeError("artworkUrl512 must be str") self.__artworkUrl512 = value artworkUrl512 = property(_get_artworkUrl512, _set_artworkUrl512) def _get_artworkUrl100(self): return self.__artworkUrl100 def _set_artworkUrl100(self, value): if not isinstance(value, str): raise TypeError("artworkUrl100 must be str") self.__artworkUrl100 = value artworkUrl100 = property(_get_artworkUrl100, _set_artworkUrl100) def _get_artistViewUrl(self): return self.__artistViewUrl def _set_artistViewUrl(self, value): if not isinstance(value, str): raise TypeError("artistViewUrl must be str") self.__artistViewUrl = value artistViewUrl = property(_get_artistViewUrl, _set_artistViewUrl) def _get_supportedDevices(self): return self.__supportedDevices def _set_supportedDevices(self, value): if not isinstance(value, list): raise TypeError("supportedDevices must be list") if not all(isinstance(i, str) for i in value): raise TypeError("supportedDevices list values must be str") self.__supportedDevices = value supportedDevices = property(_get_supportedDevices, _set_supportedDevices) def _get_advisories(self): return self.__advisories def _set_advisories(self, value): if not isinstance(value, list): raise TypeError("advisories must be list") if not all(isinstance(i, float) for i in value): raise TypeError("advisories list values must be float") self.__advisories = value advisories = property(_get_advisories, _set_advisories) def _get_isGameCenterEnabled(self): return self.__isGameCenterEnabled def _set_isGameCenterEnabled(self, value): if not isinstance(value, bool): raise TypeError("isGameCenterEnabled must be bool") self.__isGameCenterEnabled = value isGameCenterEnabled = property( _get_isGameCenterEnabled, _set_isGameCenterEnabled ) def _get_kind(self): return self.__kind def _set_kind(self, value): if not isinstance(value, str): raise TypeError("kind must be str") self.__kind = value kind = property(_get_kind, _set_kind) def _get_features(self): return self.__features def _set_features(self, value): if not isinstance(value, list): raise TypeError("features must be list") if not all(isinstance(i, str) for i in value): raise TypeError("features list values must be str") self.__features = value features = property(_get_features, _set_features) def _get_minimumOsVersion(self): return self.__minimumOsVersion def _set_minimumOsVersion(self, value): if not isinstance(value, str): raise TypeError("minimumOsVersion must be str") self.__minimumOsVersion = value minimumOsVersion = property(_get_minimumOsVersion, _set_minimumOsVersion) def _get_trackCensoredName(self): return self.__trackCensoredName def _set_trackCensoredName(self, value): if not isinstance(value, str): raise TypeError("trackCensoredName must be str") self.__trackCensoredName = value trackCensoredName = property(_get_trackCensoredName, _set_trackCensoredName) def _get_languageCodesISO2A(self): return self.__languageCodesISO2A def _set_languageCodesISO2A(self, value): if not isinstance(value, list): raise TypeError("languageCodesISO2A must be list") if not all(isinstance(i, str) for i in value): raise TypeError("languageCodesISO2A list values must be str") self.__languageCodesISO2A = value languageCodesISO2A = property(_get_languageCodesISO2A, _set_languageCodesISO2A) def _get_fileSizeBytes(self): return self.__fileSizeBytes def _set_fileSizeBytes(self, value): if not isinstance(value, str): raise TypeError("fileSizeBytes must be str") self.__fileSizeBytes = value fileSizeBytes = property(_get_fileSizeBytes, _set_fileSizeBytes) def _get_formattedPrice(self): return self.__formattedPrice def _set_formattedPrice(self, value): if not isinstance(value, str): raise TypeError("formattedPrice must be str") self.__formattedPrice = value formattedPrice = property(_get_formattedPrice, _set_formattedPrice) def _get_contentAdvisoryRating(self): return self.__contentAdvisoryRating def _set_contentAdvisoryRating(self, value): if not isinstance(value, str): raise TypeError("contentAdvisoryRating must be str") self.__contentAdvisoryRating = value contentAdvisoryRating = property( _get_contentAdvisoryRating, _set_contentAdvisoryRating ) def _get_averageUserRatingForCurrentVersion(self): return self.__averageUserRatingForCurrentVersion def _set_averageUserRatingForCurrentVersion(self, value): if not isinstance(value, float): raise TypeError("averageUserRatingForCurrentVersion must be float") self.__averageUserRatingForCurrentVersion = value averageUserRatingForCurrentVersion = property( _get_averageUserRatingForCurrentVersion, _set_averageUserRatingForCurrentVersion, ) def _get_userRatingCountForCurrentVersion(self): return self.__userRatingCountForCurrentVersion def _set_userRatingCountForCurrentVersion(self, value): if not isinstance(value, int): raise TypeError("userRatingCountForCurrentVersion must be int") self.__userRatingCountForCurrentVersion = value userRatingCountForCurrentVersion = property( _get_userRatingCountForCurrentVersion, _set_userRatingCountForCurrentVersion ) def _get_averageUserRating(self): return self.__averageUserRating def _set_averageUserRating(self, value): if not isinstance(value, float): raise TypeError("averageUserRating must be float") self.__averageUserRating = value averageUserRating = property(_get_averageUserRating, _set_averageUserRating) def _get_trackViewUrl(self): return self.__trackViewUrl def _set_trackViewUrl(self, value): if not isinstance(value, str): raise TypeError("trackViewUrl must be str") self.__trackViewUrl = value trackViewUrl = property(_get_trackViewUrl, _set_trackViewUrl) def _get_trackContentRating(self): return self.__trackContentRating def _set_trackContentRating(self, value): if not isinstance(value, str): raise TypeError("trackContentRating must be str") self.__trackContentRating = value trackContentRating = property(_get_trackContentRating, _set_trackContentRating) def _get_releaseDate(self): return self.__releaseDate def _set_releaseDate(self, value): if not isinstance(value, str): raise TypeError("releaseDate must be str") self.__releaseDate = value releaseDate = property(_get_releaseDate, _set_releaseDate) def _get_genreIds(self): return self.__genreIds def _set_genreIds(self, value): if not isinstance(value, list): raise TypeError("genreIds must be list") if not all(isinstance(i, str) for i in value): raise TypeError("genreIds list values must be str") self.__genreIds = value genreIds = property(_get_genreIds, _set_genreIds) def _get_primaryGenreName(self): return self.__primaryGenreName def _set_primaryGenreName(self, value): if not isinstance(value, str): raise TypeError("primaryGenreName must be str") self.__primaryGenreName = value primaryGenreName = property(_get_primaryGenreName, _set_primaryGenreName) def _get_trackId(self): return self.__trackId def _set_trackId(self, value): if not isinstance(value, int): raise TypeError("trackId must be int") self.__trackId = value trackId = property(_get_trackId, _set_trackId) def _get_trackName(self): return self.__trackName def _set_trackName(self, value): if not isinstance(value, str): raise TypeError("trackName must be str") self.__trackName = value trackName = property(_get_trackName, _set_trackName) def _get_sellerName(self): return self.__sellerName def _set_sellerName(self, value): if not isinstance(value, str): raise TypeError("sellerName must be str") self.__sellerName = value sellerName = property(_get_sellerName, _set_sellerName) def _get_isVppDeviceBasedLicensingEnabled(self): return self.__isVppDeviceBasedLicensingEnabled def _set_isVppDeviceBasedLicensingEnabled(self, value): if not isinstance(value, bool): raise TypeError("isVppDeviceBasedLicensingEnabled must be bool") self.__isVppDeviceBasedLicensingEnabled = value isVppDeviceBasedLicensingEnabled = property( _get_isVppDeviceBasedLicensingEnabled, _set_isVppDeviceBasedLicensingEnabled ) def _get_currentVersionReleaseDate(self): return self.__currentVersionReleaseDate def _set_currentVersionReleaseDate(self, value): if not isinstance(value, str): raise TypeError("currentVersionReleaseDate must be str") self.__currentVersionReleaseDate = value currentVersionReleaseDate = property( _get_currentVersionReleaseDate, _set_currentVersionReleaseDate ) def _get_releaseNotes(self): return self.__releaseNotes def _set_releaseNotes(self, value): if not isinstance(value, str): raise TypeError("releaseNotes must be str") self.__releaseNotes = value releaseNotes = property(_get_releaseNotes, _set_releaseNotes) def _get_primaryGenreId(self): return self.__primaryGenreId def _set_primaryGenreId(self, value): if not isinstance(value, int): raise TypeError("primaryGenreId must be int") self.__primaryGenreId = value primaryGenreId = property(_get_primaryGenreId, _set_primaryGenreId) def _get_currency(self): return self.__currency def _set_currency(self, value): if not isinstance(value, str): raise TypeError("currency must be str") self.__currency = value currency = property(_get_currency, _set_currency) def _get_version(self): return self.__version def _set_version(self, value): if not isinstance(value, str): raise TypeError("version must be str") self.__version = value version = property(_get_version, _set_version) def _get_wrapperType(self): return self.__wrapperType def _set_wrapperType(self, value): if not isinstance(value, str): raise TypeError("wrapperType must be str") self.__wrapperType = value wrapperType = property(_get_wrapperType, _set_wrapperType) def _get_artistId(self): return self.__artistId def _set_artistId(self, value): if not isinstance(value, int): raise TypeError("artistId must be int") self.__artistId = value artistId = property(_get_artistId, _set_artistId) def _get_artistName(self): return self.__artistName def _set_artistName(self, value): if not isinstance(value, str): raise TypeError("artistName must be str") self.__artistName = value artistName = property(_get_artistName, _set_artistName) def _get_genres(self): return self.__genres def _set_genres(self, value): if not isinstance(value, list): raise TypeError("genres must be list") if not all(isinstance(i, str) for i in value): raise TypeError("genres list values must be str") self.__genres = value genres = property(_get_genres, _set_genres) def _get_price(self): return self.__price def _set_price(self, value): if not isinstance(value, float): raise TypeError("price must be float") self.__price = value price = property(_get_price, _set_price) def _get_description(self): return self.__description def _set_description(self, value): if not isinstance(value, str): raise TypeError("description must be str") self.__description = value description = property(_get_description, _set_description) def _get_bundleId(self): return self.__bundleId def _set_bundleId(self, value): if not isinstance(value, str): raise TypeError("bundleId must be str") self.__bundleId = value bundleId = property(_get_bundleId, _set_bundleId) def _get_userRatingCount(self): return self.__userRatingCount def _set_userRatingCount(self, value): if not isinstance(value, int): raise TypeError("userRatingCount must be int") self.__userRatingCount = value userRatingCount = property(_get_userRatingCount, _set_userRatingCount) @staticmethod def from_dict(d): v = {} if "appletvScreenshotUrls" in d: v["appletvScreenshotUrls"] = [ float.from_dict(p) if hasattr(float, "from_dict") else p for p in d["appletvScreenshotUrls"] ] if "screenshotUrls" in d: v["screenshotUrls"] = [ str.from_dict(p) if hasattr(str, "from_dict") else p for p in d["screenshotUrls"] ] if "ipadScreenshotUrls" in d: v["ipadScreenshotUrls"] = [ str.from_dict(p) if hasattr(str, "from_dict") else p for p in d["ipadScreenshotUrls"] ] if "artworkUrl60" in d: v["artworkUrl60"] = ( str.from_dict(d["artworkUrl60"]) if hasattr(str, "from_dict") else d["artworkUrl60"] ) if "artworkUrl512" in d: v["artworkUrl512"] = ( str.from_dict(d["artworkUrl512"]) if hasattr(str, "from_dict") else d["artworkUrl512"] ) if "artworkUrl100" in d: v["artworkUrl100"] = ( str.from_dict(d["artworkUrl100"]) if hasattr(str, "from_dict") else d["artworkUrl100"] ) if "artistViewUrl" in d: v["artistViewUrl"] = ( str.from_dict(d["artistViewUrl"]) if hasattr(str, "from_dict") else d["artistViewUrl"] ) if "supportedDevices" in d: v["supportedDevices"] = [ str.from_dict(p) if hasattr(str, "from_dict") else p for p in d["supportedDevices"] ] if "advisories" in d: v["advisories"] = [ float.from_dict(p) if hasattr(float, "from_dict") else p for p in d["advisories"] ] if "isGameCenterEnabled" in d: v["isGameCenterEnabled"] = ( bool.from_dict(d["isGameCenterEnabled"]) if hasattr(bool, "from_dict") else d["isGameCenterEnabled"] ) if "kind" in d: v["kind"] = ( str.from_dict(d["kind"]) if hasattr(str, "from_dict") else d["kind"] ) if "features" in d: v["features"] = [ str.from_dict(p) if hasattr(str, "from_dict") else p for p in d["features"] ] if "minimumOsVersion" in d: v["minimumOsVersion"] = ( str.from_dict(d["minimumOsVersion"]) if hasattr(str, "from_dict") else d["minimumOsVersion"] ) if "trackCensoredName" in d: v["trackCensoredName"] = ( str.from_dict(d["trackCensoredName"]) if hasattr(str, "from_dict") else d["trackCensoredName"] ) if "languageCodesISO2A" in d: v["languageCodesISO2A"] = [ str.from_dict(p) if hasattr(str, "from_dict") else p for p in d["languageCodesISO2A"] ] if "fileSizeBytes" in d: v["fileSizeBytes"] = ( str.from_dict(d["fileSizeBytes"]) if hasattr(str, "from_dict") else d["fileSizeBytes"] ) if "formattedPrice" in d: v["formattedPrice"] = ( str.from_dict(d["formattedPrice"]) if hasattr(str, "from_dict") else d["formattedPrice"] ) if "contentAdvisoryRating" in d: v["contentAdvisoryRating"] = ( str.from_dict(d["contentAdvisoryRating"]) if hasattr(str, "from_dict") else d["contentAdvisoryRating"] ) if "averageUserRatingForCurrentVersion" in d: v["averageUserRatingForCurrentVersion"] = ( float.from_dict(d["averageUserRatingForCurrentVersion"]) if hasattr(float, "from_dict") else d["averageUserRatingForCurrentVersion"] ) if "userRatingCountForCurrentVersion" in d: v["userRatingCountForCurrentVersion"] = ( int.from_dict(d["userRatingCountForCurrentVersion"]) if hasattr(int, "from_dict") else d["userRatingCountForCurrentVersion"] ) if "averageUserRating" in d: v["averageUserRating"] = ( float.from_dict(d["averageUserRating"]) if hasattr(float, "from_dict") else d["averageUserRating"] ) if "trackViewUrl" in d: v["trackViewUrl"] = ( str.from_dict(d["trackViewUrl"]) if hasattr(str, "from_dict") else d["trackViewUrl"] ) if "trackContentRating" in d: v["trackContentRating"] = ( str.from_dict(d["trackContentRating"]) if hasattr(str, "from_dict") else d["trackContentRating"] ) if "releaseDate" in d: v["releaseDate"] = ( str.from_dict(d["releaseDate"]) if hasattr(str, "from_dict") else d["releaseDate"] ) if "genreIds" in d: v["genreIds"] = [ str.from_dict(p) if hasattr(str, "from_dict") else p for p in d["genreIds"] ] if "primaryGenreName" in d: v["primaryGenreName"] = ( str.from_dict(d["primaryGenreName"]) if hasattr(str, "from_dict") else d["primaryGenreName"] ) if "trackId" in d: v["trackId"] = ( int.from_dict(d["trackId"]) if hasattr(int, "from_dict") else d["trackId"] ) if "trackName" in d: v["trackName"] = ( str.from_dict(d["trackName"]) if hasattr(str, "from_dict") else d["trackName"] ) if "sellerName" in d: v["sellerName"] = ( str.from_dict(d["sellerName"]) if hasattr(str, "from_dict") else d["sellerName"] ) if "isVppDeviceBasedLicensingEnabled" in d: v["isVppDeviceBasedLicensingEnabled"] = ( bool.from_dict(d["isVppDeviceBasedLicensingEnabled"]) if hasattr(bool, "from_dict") else d["isVppDeviceBasedLicensingEnabled"] ) if "currentVersionReleaseDate" in d: v["currentVersionReleaseDate"] = ( str.from_dict(d["currentVersionReleaseDate"]) if hasattr(str, "from_dict") else d["currentVersionReleaseDate"] ) if "releaseNotes" in d: v["releaseNotes"] = ( str.from_dict(d["releaseNotes"]) if hasattr(str, "from_dict") else d["releaseNotes"] ) if "primaryGenreId" in d: v["primaryGenreId"] = ( int.from_dict(d["primaryGenreId"]) if hasattr(int, "from_dict") else d["primaryGenreId"] ) if "currency" in d: v["currency"] = ( str.from_dict(d["currency"]) if hasattr(str, "from_dict") else d["currency"] ) if "version" in d: v["version"] = ( str.from_dict(d["version"]) if hasattr(str, "from_dict") else d["version"] ) if "wrapperType" in d: v["wrapperType"] = ( str.from_dict(d["wrapperType"]) if hasattr(str, "from_dict") else d["wrapperType"] ) if "artistId" in d: v["artistId"] = ( int.from_dict(d["artistId"]) if hasattr(int, "from_dict") else d["artistId"] ) if "artistName" in d: v["artistName"] = ( str.from_dict(d["artistName"]) if hasattr(str, "from_dict") else d["artistName"] ) if "genres" in d: v["genres"] = [ str.from_dict(p) if hasattr(str, "from_dict") else p for p in d["genres"] ] if "price" in d: v["price"] = ( float.from_dict(d["price"]) if hasattr(float, "from_dict") else d["price"] ) if "description" in d: v["description"] = ( str.from_dict(d["description"]) if hasattr(str, "from_dict") else d["description"] ) if "bundleId" in d: v["bundleId"] = ( str.from_dict(d["bundleId"]) if hasattr(str, "from_dict") else d["bundleId"] ) if "userRatingCount" in d: v["userRatingCount"] = ( int.from_dict(d["userRatingCount"]) if hasattr(int, "from_dict") else d["userRatingCount"] ) return ItunesLookupResp._results(**v) def as_dict(self): d = {} if self.__appletvScreenshotUrls is not None: d["appletvScreenshotUrls"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__appletvScreenshotUrls ] if self.__screenshotUrls is not None: d["screenshotUrls"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__screenshotUrls ] if self.__ipadScreenshotUrls is not None: d["ipadScreenshotUrls"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__ipadScreenshotUrls ] if self.__artworkUrl60 is not None: d["artworkUrl60"] = ( self.__artworkUrl60.as_dict() if hasattr(self.__artworkUrl60, "as_dict") else self.__artworkUrl60 ) if self.__artworkUrl512 is not None: d["artworkUrl512"] = ( self.__artworkUrl512.as_dict() if hasattr(self.__artworkUrl512, "as_dict") else self.__artworkUrl512 ) if self.__artworkUrl100 is not None: d["artworkUrl100"] = ( self.__artworkUrl100.as_dict() if hasattr(self.__artworkUrl100, "as_dict") else self.__artworkUrl100 ) if self.__artistViewUrl is not None: d["artistViewUrl"] = ( self.__artistViewUrl.as_dict() if hasattr(self.__artistViewUrl, "as_dict") else self.__artistViewUrl ) if self.__supportedDevices is not None: d["supportedDevices"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__supportedDevices ] if self.__advisories is not None: d["advisories"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__advisories ] if self.__isGameCenterEnabled is not None: d["isGameCenterEnabled"] = ( self.__isGameCenterEnabled.as_dict() if hasattr(self.__isGameCenterEnabled, "as_dict") else self.__isGameCenterEnabled ) if self.__kind is not None: d["kind"] = ( self.__kind.as_dict() if hasattr(self.__kind, "as_dict") else self.__kind ) if self.__features is not None: d["features"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__features ] if self.__minimumOsVersion is not None: d["minimumOsVersion"] = ( self.__minimumOsVersion.as_dict() if hasattr(self.__minimumOsVersion, "as_dict") else self.__minimumOsVersion ) if self.__trackCensoredName is not None: d["trackCensoredName"] = ( self.__trackCensoredName.as_dict() if hasattr(self.__trackCensoredName, "as_dict") else self.__trackCensoredName ) if self.__languageCodesISO2A is not None: d["languageCodesISO2A"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__languageCodesISO2A ] if self.__fileSizeBytes is not None: d["fileSizeBytes"] = ( self.__fileSizeBytes.as_dict() if hasattr(self.__fileSizeBytes, "as_dict") else self.__fileSizeBytes ) if self.__formattedPrice is not None: d["formattedPrice"] = ( self.__formattedPrice.as_dict() if hasattr(self.__formattedPrice, "as_dict") else self.__formattedPrice ) if self.__contentAdvisoryRating is not None: d["contentAdvisoryRating"] = ( self.__contentAdvisoryRating.as_dict() if hasattr(self.__contentAdvisoryRating, "as_dict") else self.__contentAdvisoryRating ) if self.__averageUserRatingForCurrentVersion is not None: d["averageUserRatingForCurrentVersion"] = ( self.__averageUserRatingForCurrentVersion.as_dict() if hasattr(self.__averageUserRatingForCurrentVersion, "as_dict") else self.__averageUserRatingForCurrentVersion ) if self.__userRatingCountForCurrentVersion is not None: d["userRatingCountForCurrentVersion"] = ( self.__userRatingCountForCurrentVersion.as_dict() if hasattr(self.__userRatingCountForCurrentVersion, "as_dict") else self.__userRatingCountForCurrentVersion ) if self.__averageUserRating is not None: d["averageUserRating"] = ( self.__averageUserRating.as_dict() if hasattr(self.__averageUserRating, "as_dict") else self.__averageUserRating ) if self.__trackViewUrl is not None: d["trackViewUrl"] = ( self.__trackViewUrl.as_dict() if hasattr(self.__trackViewUrl, "as_dict") else self.__trackViewUrl ) if self.__trackContentRating is not None: d["trackContentRating"] = ( self.__trackContentRating.as_dict() if hasattr(self.__trackContentRating, "as_dict") else self.__trackContentRating ) if self.__releaseDate is not None: d["releaseDate"] = ( self.__releaseDate.as_dict() if hasattr(self.__releaseDate, "as_dict") else self.__releaseDate ) if self.__genreIds is not None: d["genreIds"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__genreIds ] if self.__primaryGenreName is not None: d["primaryGenreName"] = ( self.__primaryGenreName.as_dict() if hasattr(self.__primaryGenreName, "as_dict") else self.__primaryGenreName ) if self.__trackId is not None: d["trackId"] = ( self.__trackId.as_dict() if hasattr(self.__trackId, "as_dict") else self.__trackId ) if self.__trackName is not None: d["trackName"] = ( self.__trackName.as_dict() if hasattr(self.__trackName, "as_dict") else self.__trackName ) if self.__sellerName is not None: d["sellerName"] = ( self.__sellerName.as_dict() if hasattr(self.__sellerName, "as_dict") else self.__sellerName ) if self.__isVppDeviceBasedLicensingEnabled is not None: d["isVppDeviceBasedLicensingEnabled"] = ( self.__isVppDeviceBasedLicensingEnabled.as_dict() if hasattr(self.__isVppDeviceBasedLicensingEnabled, "as_dict") else self.__isVppDeviceBasedLicensingEnabled ) if self.__currentVersionReleaseDate is not None: d["currentVersionReleaseDate"] = ( self.__currentVersionReleaseDate.as_dict() if hasattr(self.__currentVersionReleaseDate, "as_dict") else self.__currentVersionReleaseDate ) if self.__releaseNotes is not None: d["releaseNotes"] = ( self.__releaseNotes.as_dict() if hasattr(self.__releaseNotes, "as_dict") else self.__releaseNotes ) if self.__primaryGenreId is not None: d["primaryGenreId"] = ( self.__primaryGenreId.as_dict() if hasattr(self.__primaryGenreId, "as_dict") else self.__primaryGenreId ) if self.__currency is not None: d["currency"] = ( self.__currency.as_dict() if hasattr(self.__currency, "as_dict") else self.__currency ) if self.__version is not None: d["version"] = ( self.__version.as_dict() if hasattr(self.__version, "as_dict") else self.__version ) if self.__wrapperType is not None: d["wrapperType"] = ( self.__wrapperType.as_dict() if hasattr(self.__wrapperType, "as_dict") else self.__wrapperType ) if self.__artistId is not None: d["artistId"] = ( self.__artistId.as_dict() if hasattr(self.__artistId, "as_dict") else self.__artistId ) if self.__artistName is not None: d["artistName"] = ( self.__artistName.as_dict() if hasattr(self.__artistName, "as_dict") else self.__artistName ) if self.__genres is not None: d["genres"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__genres ] if self.__price is not None: d["price"] = ( self.__price.as_dict() if hasattr(self.__price, "as_dict") else self.__price ) if self.__description is not None: d["description"] = ( self.__description.as_dict() if hasattr(self.__description, "as_dict") else self.__description ) if self.__bundleId is not None: d["bundleId"] = ( self.__bundleId.as_dict() if hasattr(self.__bundleId, "as_dict") else self.__bundleId ) if self.__userRatingCount is not None: d["userRatingCount"] = ( self.__userRatingCount.as_dict() if hasattr(self.__userRatingCount, "as_dict") else self.__userRatingCount ) return d def __repr__(self): return "".format( limitedRepr( self.__appletvScreenshotUrls[:20] if isinstance(self.__appletvScreenshotUrls, bytes) else self.__appletvScreenshotUrls ), limitedRepr( self.__screenshotUrls[:20] if isinstance(self.__screenshotUrls, bytes) else self.__screenshotUrls ), limitedRepr( self.__ipadScreenshotUrls[:20] if isinstance(self.__ipadScreenshotUrls, bytes) else self.__ipadScreenshotUrls ), limitedRepr( self.__artworkUrl60[:20] if isinstance(self.__artworkUrl60, bytes) else self.__artworkUrl60 ), limitedRepr( self.__artworkUrl512[:20] if isinstance(self.__artworkUrl512, bytes) else self.__artworkUrl512 ), limitedRepr( self.__artworkUrl100[:20] if isinstance(self.__artworkUrl100, bytes) else self.__artworkUrl100 ), limitedRepr( self.__artistViewUrl[:20] if isinstance(self.__artistViewUrl, bytes) else self.__artistViewUrl ), limitedRepr( self.__supportedDevices[:20] if isinstance(self.__supportedDevices, bytes) else self.__supportedDevices ), limitedRepr( self.__advisories[:20] if isinstance(self.__advisories, bytes) else self.__advisories ), limitedRepr( self.__isGameCenterEnabled[:20] if isinstance(self.__isGameCenterEnabled, bytes) else self.__isGameCenterEnabled ), limitedRepr( self.__kind[:20] if isinstance(self.__kind, bytes) else self.__kind ), limitedRepr( self.__features[:20] if isinstance(self.__features, bytes) else self.__features ), limitedRepr( self.__minimumOsVersion[:20] if isinstance(self.__minimumOsVersion, bytes) else self.__minimumOsVersion ), limitedRepr( self.__trackCensoredName[:20] if isinstance(self.__trackCensoredName, bytes) else self.__trackCensoredName ), limitedRepr( self.__languageCodesISO2A[:20] if isinstance(self.__languageCodesISO2A, bytes) else self.__languageCodesISO2A ), limitedRepr( self.__fileSizeBytes[:20] if isinstance(self.__fileSizeBytes, bytes) else self.__fileSizeBytes ), limitedRepr( self.__formattedPrice[:20] if isinstance(self.__formattedPrice, bytes) else self.__formattedPrice ), limitedRepr( self.__contentAdvisoryRating[:20] if isinstance(self.__contentAdvisoryRating, bytes) else self.__contentAdvisoryRating ), limitedRepr( self.__averageUserRatingForCurrentVersion[:20] if isinstance(self.__averageUserRatingForCurrentVersion, bytes) else self.__averageUserRatingForCurrentVersion ), limitedRepr( self.__userRatingCountForCurrentVersion[:20] if isinstance(self.__userRatingCountForCurrentVersion, bytes) else self.__userRatingCountForCurrentVersion ), limitedRepr( self.__averageUserRating[:20] if isinstance(self.__averageUserRating, bytes) else self.__averageUserRating ), limitedRepr( self.__trackViewUrl[:20] if isinstance(self.__trackViewUrl, bytes) else self.__trackViewUrl ), limitedRepr( self.__trackContentRating[:20] if isinstance(self.__trackContentRating, bytes) else self.__trackContentRating ), limitedRepr( self.__releaseDate[:20] if isinstance(self.__releaseDate, bytes) else self.__releaseDate ), limitedRepr( self.__genreIds[:20] if isinstance(self.__genreIds, bytes) else self.__genreIds ), limitedRepr( self.__primaryGenreName[:20] if isinstance(self.__primaryGenreName, bytes) else self.__primaryGenreName ), limitedRepr( self.__trackId[:20] if isinstance(self.__trackId, bytes) else self.__trackId ), limitedRepr( self.__trackName[:20] if isinstance(self.__trackName, bytes) else self.__trackName ), limitedRepr( self.__sellerName[:20] if isinstance(self.__sellerName, bytes) else self.__sellerName ), limitedRepr( self.__isVppDeviceBasedLicensingEnabled[:20] if isinstance(self.__isVppDeviceBasedLicensingEnabled, bytes) else self.__isVppDeviceBasedLicensingEnabled ), limitedRepr( self.__currentVersionReleaseDate[:20] if isinstance(self.__currentVersionReleaseDate, bytes) else self.__currentVersionReleaseDate ), limitedRepr( self.__releaseNotes[:20] if isinstance(self.__releaseNotes, bytes) else self.__releaseNotes ), limitedRepr( self.__primaryGenreId[:20] if isinstance(self.__primaryGenreId, bytes) else self.__primaryGenreId ), limitedRepr( self.__currency[:20] if isinstance(self.__currency, bytes) else self.__currency ), limitedRepr( self.__version[:20] if isinstance(self.__version, bytes) else self.__version ), limitedRepr( self.__wrapperType[:20] if isinstance(self.__wrapperType, bytes) else self.__wrapperType ), limitedRepr( self.__artistId[:20] if isinstance(self.__artistId, bytes) else self.__artistId ), limitedRepr( self.__artistName[:20] if isinstance(self.__artistName, bytes) else self.__artistName ), limitedRepr( self.__genres[:20] if isinstance(self.__genres, bytes) else self.__genres ), limitedRepr( self.__price[:20] if isinstance(self.__price, bytes) else self.__price ), limitedRepr( self.__description[:20] if isinstance(self.__description, bytes) else self.__description ), limitedRepr( self.__bundleId[:20] if isinstance(self.__bundleId, bytes) else self.__bundleId ), limitedRepr( self.__userRatingCount[:20] if isinstance(self.__userRatingCount, bytes) else self.__userRatingCount ), ) _types_map = { "resultCount": {"type": int, "subtype": None}, "results": {"type": list, "subtype": _results}, } _formats_map = {} _validations_map = { "resultCount": { "required": True, }, "results": { "required": True, }, } def __init__(self, resultCount: int = None, results: List[_results] = None): pass self.__resultCount = resultCount self.__results = results def _get_resultCount(self): return self.__resultCount def _set_resultCount(self, value): if not isinstance(value, int): raise TypeError("resultCount must be int") self.__resultCount = value resultCount = property(_get_resultCount, _set_resultCount) def _get_results(self): return self.__results def _set_results(self, value): if not isinstance(value, list): raise TypeError("results must be list") if not all(isinstance(i, ItunesLookupResp._results) for i in value): raise TypeError("results list values must be ItunesLookupResp._results") self.__results = value results = property(_get_results, _set_results) @staticmethod def from_dict(d): v = {} if "resultCount" in d: v["resultCount"] = ( int.from_dict(d["resultCount"]) if hasattr(int, "from_dict") else d["resultCount"] ) if "results" in d: v["results"] = [ ItunesLookupResp._results.from_dict(p) if hasattr(ItunesLookupResp._results, "from_dict") else p for p in d["results"] ] return ItunesLookupResp(**v) def as_dict(self): d = {} if self.__resultCount is not None: d["resultCount"] = ( self.__resultCount.as_dict() if hasattr(self.__resultCount, "as_dict") else self.__resultCount ) if self.__results is not None: d["results"] = [ p.as_dict() if hasattr(p, "as_dict") else p for p in self.__results ] return d def __repr__(self): return "".format( limitedRepr( self.__resultCount[:20] if isinstance(self.__resultCount, bytes) else self.__resultCount ), limitedRepr( self.__results[:20] if isinstance(self.__results, bytes) else self.__results ), )