Get the genres from the Podcasts browse tab dropdown.

		Returns:
			list: Genre groups that contain sub groups.
181024
def browse_podcasts_genres(self):
		

		response = self._call(
			mc_calls.PodcastBrowseHierarchy
		)
		genres = response.body.get('groups', [])

		return genres
248825
def generate_urls_for_genre(self, genre_url):
    
    letters = list(string.ascii_uppercase)
    urls = []
    for letter in letters:
      base = '{}&letter={}'.format(genre_url, letter)
      page = r.get(base)
      tree = html.fromstring(page.content)
      elements = tree.xpath("//ul[@class='list paginate']")
      if not elements:
        urls.append(base)
      else:
        for i in xrange(1, self._find_num_pages(base)):
          urls.append('{}&page={}#page'.format(base, i))
    return urls
106951
def classificationgroup(self):
        """"""
        path = ['author-profile', 'classificationgroup', 'classifications',
                'classification']
        out = [(item['$'], item['@frequency']) for item in
               listify(chained_get(self._json, path, []))]
        return out or None
375067
def groups(self) -> Set[str]:
        
        return set(opt.group_name for opt in self._options.values())
527052
def genres
      doc.xpath("//h4[contains(., 'Genre')]/..").search("a").map { |g|
        g.content.strip unless g.content =~ /See more/
      }.compact
    rescue
      nil
    end
265170
def get_object(self, queryset=None):
        """"""
        if settings.PODCAST_SINGULAR:
            show = get_object_or_404(Show, id=settings.PODCAST_ID)
        else:
            show = get_object_or_404(Show, slug=self.kwargs['show_slug'])
        obj = get_object_or_404(Episode, show=show, slug=self.kwargs['slug'])
        index = Episode.objects.is_public_or_secret().filter(show=show, pub_date__lt=obj.pub_date).count()
        obj.index = index + 1
        obj.index_next = obj.index + 1
        obj.index_previous = obj.index - 1
        return obj
825022
def group_plugins_into_categories(plugins):
    
    if not plugins:
        return {}
    plugins = sorted(plugins, key=lambda p: p.verbose_name)
    categories = {}

    for plugin in plugins:
        title = str(plugin.category or u"")  # enforce resolving ugettext_lazy proxies.
        if title not in categories:
            categories[title] = []
        categories[title].append(plugin)

    return categories
1122462
def parse_podcast(url):
    
    try:
        podcast = feedparser.parse(url)
        wentwrong = "urlopen" in str(podcast["bozo_exception"])
    except KeyError:
        wentwrong = False
    if wentwrong:
        print("Error: ", url, ": ", str(podcast["bozo_exception"]))
    return podcast
1262788
def select_groups(adata, groups='all', key='louvain'):
    
    strings_to_categoricals(adata)
    if isinstance(groups, list) and isinstance(groups[0], int): groups = [str(n) for n in groups]
    categories = adata.obs[key].cat.categories
    groups_masks = np.array([categories[i] == adata.obs[key].values for i, name in enumerate(categories)])
    if groups == 'all':
        groups = categories.values
    else:
        groups_ids = [np.where(categories.values == name)[0][0] for name in groups]
        groups_masks = groups_masks[groups_ids]
        groups = categories[groups_ids].values
    return groups, groups_masks
411433
public StringArray getCategories() {
    if (GOMention_Type.featOkTst && ((GOMention_Type)jcasType).casFeat_categories == null)
      jcasType.jcas.throwFeatMissing("categories", "de.julielab.jules.types.GOMention");
    return (StringArray)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((GOMention_Type)jcasType).casFeatCode_categories)));}
329813
def top_charts_for_genre(self, genre_id):
		

		response = self._call(mc_calls.BrowseTopChartForGenre, genre_id)
		top_chart_for_genre = response.body

		return top_chart_for_genre
414662
def get_playlists(self, search, start=0, max_items=100):
        
        return self.get_music_service_information('playlists', search, start,
                                                  max_items)
1254556
def analyze_with_categories(self, webpage):
        
        detected_apps = self.analyze(webpage)
        categorised_apps = {}

        for app_name in detected_apps:
            cat_names = self.get_categories(app_name)
            categorised_apps[app_name] = {"categories": cat_names}

        return categorised_apps
130306
def get_favorite_radio_shows(self, *args, **kwargs):
        
        args = tuple(['radio_shows'] + list(args))
        return self.get_music_library_information(*args, **kwargs)
299276
def groups(self):
        
        _tables()
        self._check_if_open()
        return [
            g for g in self._handle.walk_groups()
            if (not isinstance(g, _table_mod.link.Link) and
                (getattr(g._v_attrs, 'pandas_type', None) or
                 getattr(g, 'table', None) or
                (isinstance(g, _table_mod.table.Table) and
                 g._v_name != 'table')))
        ]
189262
public function getGenre()
    {
        if ($this->genre === null) {
            $match = [];
            preg_match(self::$REGEX_GENRE, $this->output, $match);
            $this->genre = array_key_exists(2, $match) ? trim($match[2]) : '';
        }

        return $this->genre;
    }
1227074
def getreadergroups(self):
        
        innerreadergroups.getreadergroups(self)

        hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
        if hresult != 0:
            raise EstablishContextException(hresult)
        hresult, readers = SCardListReaderGroups(hcontext)
        if hresult != 0:
            raise ListReadersException(hresult)
        hresult = SCardReleaseContext(hcontext)
        if hresult != 0:
            raise ReleaseContextException(hresult)
        return readers