def __init__(self, json_data):
        self.entityType	 = None   #string	audio album / audio single / internet / video
        self.title	 = None   #string	Title of the release
        self.type	 = None   #string	Release type. More specific than entityType
        self.date	 = None   #partial date	Release date
        self.label	 = None   #label	The label of the release
        self.catalogNr = None   	#string	Catalog number
        self.ean	 = None       #string	EAN code
        self.picture	 = None       #picture	Picture of the release art
        self.tributes	 = None   #list of artist	Tributed artists
        self.performances = None	#list of performance	Release tracks
        self.external_uri = None	#Discogs

        self._initialize_fields_from_json_data({required("entityType"): voluptuous.any(u"audio album",
                                                                                        u"audio single",
                                                                                        u"internet",
                                                                                        u"video"),
                                                required("uri"):basestring,
                                                "title": unicode,
                                               "type": unicode,
                                               "date": isPartialDate,
                                               "label": coerce(ShsLabel),
                                               "catalogNr": unicode,
                                               "ean": _voluptuous_any_or_null(unicode),
                                               "picture": coerce(ShsPicture),
                                               "tributes": [coerce(ShsArtist)],
                                               "performances": [coerce(ShsPerformance)],
                                               "external_uri": [unicode], },
                                        json_data)
        self.json_data = json_data
    def __init__(self, json_data):
        self.name = None	#string	Name of the label
        self._initialize_fields_from_json_data({required("entityType"): "label",
                                                required("uri") : basestring,
                                                required("name"): unicode,
                                                "picture" : _voluptuous_any_or_null(coerce(ShsPicture))
                                                },

                                        json_data)
        self.json_data = json_data
    def __init__(self, json_data):
        self.entityType = None #Always 'artist'
        self.name = None #Name of the performer
        self.artist = None #Artist of which this performer is an alias. Omitted when the performer is obvious from the context
        self._initialize_fields_from_json_data({
#                                                required("entityType"): u"artist",
                                                "entityType": u"artist", # counterexample song=1000 performer has only name
                                                "name": unicode,
                                                "artist": coerce(ShsArtist)},
                                                json_data, extraKeys=False)
        self.json_data = json_data
 def __init__(self, json_data):
     self.entityType	 = None    #string	song / poem / film / proza
     self.title	 = None    #string	title of the work
     self.language	 = None    #string	language of the work
     self.credits	 = None    #list of artist	credited artists
     self.originalCredits = None	#list of artist	artists credits for the works on which this work is based
     self.original	 = None    #performance	original performance
     self.basedOn	 = None    #list of work	works on which this work is based
     self.derivedWorks	 = None    #list of work	works derived from this work
     self.versions	 = None    #list of performance	versions of this work
     self._initialize_fields_from_json_data({required("entityType"): voluptuous.any(u"song",
                                                                                     u"poem",
                                                                                     u"film",
                                                                                     u"proza"),
                                     required("uri"):basestring,
                                     "title": unicode,
                                    "language": _voluptuous_any_or_null(unicode),
                                    "credits": [coerce(ShsArtist)],
                                    "originalCredits": [coerce(ShsArtist)],
                                    "original": coerce(ShsPerformance),
                                    "basedOn": [coerce(ShsWork)],
                                    "derivedWorks": [coerce(ShsWork)],
                                    "versions": [coerce(ShsPerformance)]},
                             json_data)
     self.json_data = json_data
    def __init__(self, json_data):
        self.entityType	 = None #string	performance / recording (in case it is recorded)
        self.title	 = None #string	title of the performance
        self.performer	 = None #performer	performer
        self.date	 = None #partial date	Performance or recording date. NOT the release date (see releases)
        self.releases	 = None #list of release	Releases on which the performance has been released
        self.works	 = None #list of work	Performed works. Usually just one work, except for medleys
        self.originals	 = None #list of work	In case of a cover: original performances per work. Each work has an additional attribute 'original' referring to the original performance and an attribute 'isRootWork' (which is true if the work is not an adaptation)
        self.covers	 = None # list of performance	In case of an original: list of covers
        self.derivedWorks = None #	list of work	In case of a cover: list of works derived from the work of the performance
        self.external_uri = None #	 	youtube videos
        self._initialize_fields_from_json_data({required("entityType"): voluptuous.any(u"performance",
                                                                                        u"recording"),
                                                required("uri"):basestring,
                                                "title": unicode,
                                               "performer": coerce(ShsPerformer),
                                               "date": isPartialDate,
                                               "releases":[coerce(ShsRelease)],
                                               "works": [coerce(ShsWork)],
                                               "originals": [coerce(ShsWork)],
                                               "covers": [coerce(ShsPerformance)],
                                               "derivedWorks": [coerce(ShsWork)],
                                               "external_uri": [unicode]},
                                        json_data)

        self.json_data = json_data
 def __init__(self, json_data):
     self.relationName = None #enumeration: has as member / is member of / family of / related
     self.comments = None #Specific details about the relationship, e.g. 'sister'
     self.artist = None #Related artist
     self._initialize_fields_from_json_data({"relationName": voluptuous.any("member",
                                                                            "is member of",
                                                                            "family of",
                                                                            "related"),
                                             "comments": voluptuous.any(unicode,
                                                                        NoneType),
                                             "artist": coerce(ShsArtist)},
                                             json_data)
     self.json_data = json_data
    def __init__(self, json_data):
        self.entityType	 = None #string	artist / joint-artist
        self.commonName	 = None #string	The name by which the artist is mostly referred to
        self.picture	 = None #picture	(artist only) Picture of the artist
        self.birthDate	 = None #partial date	(artist only) Birth date of the artist
        self.deathDate	 = None #partial date	(artist only) Death date of the artist
        self.homeCountry = None #	string	(artist only) Country mostly associated with the artist
        self.comments	 = None #string	(artist only) Comments
        self.aliases	 = None #list of string	List of other names used by this artist
        self.relations	 = None #list of relation	(artist only) Related artists
        self.members	 = None #list of artist	(joint artist only) Artists that are part of the joint artist

        self.performances_uri = None
        self.creditedWorks_uri = None
        self.releases_uri = None

        self._getter_factory_functions = dict()

        self._initialize_fields_from_json_data({required("entityType"): voluptuous.any(u"artist"
                                                                                       , u"joint-artist"),
                                                required("uri"):basestring,
                                                "commonName": unicode,
                                               "picture": coerce(ShsPicture),
                                               "birthDate": isPartialDate,
                                               "deathDate": isPartialDate,
                                               "homeCountry": unicode,
                                               "comments": unicode,
                                               "aliases": [unicode],
                                               "relations": [coerce(ShsRelation)],
                                               "members": [coerce(ShsArtist)],
        },
                                        json_data)

        self._initialize_url_fields({"performances": lambda xs: [ShsPerformance(x) for x in xs],
                                     "creditedWorks": lambda xs: [ShsWork(x) for x in xs],
                                     "releases": lambda xs: [ShsRelease(x) for x in xs]},
                                    json_data)
        self.json_data = json_data