docs: def static(type='artist', artist_pick='song_hotttnesss-desc', variety=.5, artist_id=None, artist=None, song_id=None,
             track_id=None, description=None, style=None, mood=None, results=15, max_tempo=None, min_tempo=None,
             max_duration=None, min_duration=None, max_loudness=None, min_loudness=None, max_danceability=None,
             min_danceability=None, max_energy=None, min_energy=None, artist_max_familiarity=None,
             artist_min_familiarity=None, artist_max_hotttnesss=None, artist_min_hotttnesss=None,
             song_max_hotttnesss=None, song_min_hotttnesss=None, min_longitude=None, max_longitude=None,
             min_latitude=None, max_latitude=None, adventurousness=0.2, mode=None, key=None, buckets=None, sort=None,
             limit=False, seed_catalog=None, source_catalog=None, rank_type=None, test_new_things=None,
             artist_start_year_after=None, artist_start_year_before=None, artist_end_year_after=None,
             artist_end_year_before=None, dmca=False, distribution=None, song_type=None, genres=None):
      """Get a static playlist
      
      Args:
      
      Kwargs:
          type (str): a string representing the playlist type ('artist', 'artist-radio', ...)
          
          artist_pick (str): How songs should be chosen for each artist
          
          variety (float): A number between 0 and 1 specifying the variety of the playlist
          
          artist_id (str): the artist_id
          
          artist (str): the name of an artist
          
          song_id (str): the song_id
          
          track_id (str): the track id
          
          description (str): A string describing the artist and song
          
          style (str): A string describing the style/genre of the artist and song
      
          mood (str): A string describing the mood of the artist and song
          
          results (int): An integer number of results to return
      
          max_tempo (float): The max tempo of song results
      
          min_tempo (float): The min tempo of song results
      
          max_duration (float): The max duration of song results
      
          min_duration (float): The min duration of song results
      
          max_loudness (float): The max loudness of song results
      
          min_loudness (float): The min loudness of song results
      
          artist_max_familiarity (float): A float specifying the max familiarity of artists to search for
      
          artist_min_familiarity (float): A float specifying the min familiarity of artists to search for
      
          artist_max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
      
          artist_min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
      
          song_max_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
      
          song_min_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
      
          max_energy (float): The max energy of song results
      
          min_energy (float): The min energy of song results
      
          max_danceability (float): The max danceability of song results
      
          min_danceability (float): The min danceability of song results
      
          mode (int): 0 or 1 (minor or major)
      
          key (int): 0-11 (c, c-sharp, d, e-flat, e, f, f-sharp, g, a-flat, a, b-flat, b)
      
          max_latitude (float): A float specifying the max latitude of artists to search for
      
          min_latitude (float): A float specifying the min latitude of artists to search for
      
          max_longitude (float): A float specifying the max longitude of artists to search for
      
          min_longitude (float): A float specifying the min longitude of artists to search for                        
          
          adventurousness (float): A float ranging from 0 for old favorites to 1.0 for unheard music according to a seed_catalog
      
          sort (str): A string indicating an attribute and order for sorting the results
      
          buckets (list): A list of strings specifying which buckets to retrieve
      
          limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
          
          seed_catalog (str or Catalog): An Artist Catalog object or Artist Catalog id to use as a seed
          
          source_catalog (str or Catalog): A Catalog object or catalog id
  
          rank_type (str): A string denoting the desired ranking for description searches, either 'relevance' or 'familiarity'    
          
          artist_start_year_before (int): Returned song's artists will have started recording music before this year.
          
          artist_start_year_after (int): Returned song's artists will have started recording music after this year.
          
          artist_end_year_before (int): Returned song's artists will have stopped recording music before this year.
          
          artist_end_year_after (int): Returned song's artists will have stopped recording music after this year.
  
          distribution (str): Affects the range of artists returned and how many songs each artist will have in the playlist relative to how similar they are to the seed. (wandering, focused)
  
          song_type (str):  A string or list of strings of the type of songs allowed.  The only valid song type at the moment is 'christmas'.
                            Valid formats are 'song_type', 'song_type:true', 'song_type:false', or 'song_type:any'.
  
      Returns:
          A list of Song objects
      
      Example:
      
      >>> p = playlist.static(type='artist-radio', artist=['ida maria', 'florence + the machine'])
      >>> p
      [<song - Pickpocket>,
       <song - Self-Taught Learner>,
       <song - Maps>,
       <song - Window Blues>,
       <song - That's Not My Name>,
       <song - My Lover Will Go>,
       <song - Home Sweet Home>,
       <song - Stella & God>,
       <song - Don't You Want To Share The Guilt?>,
       <song - Forget About It>,
       <song - Dull Life>,
       <song - This Trumpet In My Head>,
       <song - Keep Your Head>,
       <song - One More Time>,
       <song - Knights in Mountain Fox Jackets>]
      >>> 
  
      """
      limit = str(limit).lower()
  
      if seed_catalog and isinstance(seed_catalog, catalog.Catalog):
          seed_catalog = seed_catalog.id
  
      if source_catalog and isinstance(source_catalog, catalog.Catalog):
          source_catalog = source_catalog.id
      dmca = str(dmca).lower()
      kwargs = locals()
      kwargs['bucket'] = kwargs['buckets'] or []
      del kwargs['buckets']
      kwargs['genre'] = kwargs['genres']
      del kwargs['genres']
  
      result = util.callm("%s/%s" % ('playlist', 'static'), kwargs)
      return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]