Get series episodes
431687
def get_series_episodes(self, id, page=1):
        """"""
        # perform the request
        params = {'page': page}
        r = self.session.get(self.base_url + '/series/{}/episodes'.format(id), params=params)
        if r.status_code == 404:
            return None
        r.raise_for_status()

        return r.json()
1066456
public Episode getEpisodeById(String episodeId, String language) throws TvDbException {
        StringBuilder urlBuilder = new StringBuilder();

        urlBuilder.append(BASE_URL)
                  .append(apiKey)
                  .append("/episodes/")
                  .append(episodeId)
                  .append("/");
        if (StringUtils.isNotBlank(language)) {
            urlBuilder.append(language);
            urlBuilder.append(XML_EXTENSION);
        }

        LOG.trace(URL, urlBuilder.toString());
        return TvdbParser.getEpisode(urlBuilder.toString());
    }
1186527
public ResultList<Artwork> getEpisodeImages(int tvID, int seasonNumber, int episodeNumber) throws MovieDbException {
        TmdbParameters parameters = new TmdbParameters();
        parameters.add(Param.ID, tvID);
        parameters.add(Param.SEASON_NUMBER, seasonNumber);
        parameters.add(Param.EPISODE_NUMBER, episodeNumber);

        URL url = new ApiUrl(apiKey, MethodBase.EPISODE).subMethod(MethodSub.IMAGES).buildUrl(parameters);
        String webpage = httpTools.getRequest(url);

        try {
            WrapperImages wrapper = MAPPER.readValue(webpage, WrapperImages.class);
            ResultList<Artwork> results = new ResultList<>(wrapper.getAll());
            wrapper.setResultProperties(results);
            return results;
        } catch (IOException ex) {
            throw new MovieDbException(ApiExceptionType.MAPPING_FAILED, "Failed to get images", url, ex);
        }
    }
476681
def browse_podcasts(self, podcast_genre_id='JZCpodcasttopchartall'):
		

		response = self._call(
			mc_calls.PodcastBrowse,
			podcast_genre_id=podcast_genre_id
		)
		podcast_series_list = response.body.get('series', [])

		return podcast_series_list
956981
def find_series_by_id(series_id, options={})
      series_url = "/series/#{series_id}"
      series_url << "/all" if options[:all]
      series_url << "/#{self.language}.xml"
      result = self.get_with_key(series_url)['Data']
      return nil unless result && result['Series']
      return result if options[:all]
      return result["Series"] if options[:raw]
      Series.new(self, result["Series"])
    end
1224143
public FTSeries getTvArtwork(String id) throws FanartTvException {
        URL url = ftapi.getImageUrl(BaseType.TV, id);
        String page = requestWebPage(url);

        FTSeries series = null;

        try {
            series = mapper.readValue(page, FTSeries.class);
        } catch (IOException ex) {
            throw new FanartTvException(ApiExceptionType.MAPPING_FAILED, "Failed to get data for ID " + id, url, ex);
        }

        if (series.isError()) {
            throw new FanartTvException(ApiExceptionType.ID_NOT_FOUND, series.getErrorMessage());
        }

        return series;
    }
1049808
def get_recent_seasons(self):
        

        recent_seasons_url = self.api_path + "recent_seasons/"
        response = self.get_response(recent_seasons_url)
        return response
1267034
function(){
    var _self = this,
      series = _self.getSeries();
    return Util.filter(series,function(item){
      return item.get('visible');
    });
  }
776156
public function getEpisodesByShowID($ID){

		$url = self::APIURL.'/shows/'.$ID.'/episodes';

		$episodes = $this->getFile($url);

		$allEpisodes = [];
		foreach($episodes as $episode){
			$ep = new Episode($episode);
			$allEpisodes[] = $ep;
		}

		return $allEpisodes;
	}
406185
private function getEpisodeTitle($each_episode, $type = false)
    {
        $title = $each_episode->find('.episode-title', 0);
        if ($type) {
            if ($title->find('span', 1)) {
                return trim($title->find('span', 1)->plaintext);
            }

            return trim($title->find('span', 0)->plaintext);
        } else {
            return $title->find('a', 0)->plaintext;
        }
    }
605446
def get_series_by_id(self, series_id):
        
        series = trakt.Trakt['search'].lookup(series_id, 'trakt-show')
        if not series:
            return None, 'Not Found'
        return series, None
36033
def _format_episode_numbers(episodenumbers):
    """"""
    if len(episodenumbers) == 1:
        epno = cfg.CONF.episode_single % episodenumbers[0]
    else:
        epno = cfg.CONF.episode_separator.join(
            cfg.CONF.episode_single % x for x in episodenumbers)

    return epno
66703
def hasSeries(self):
        
        if len(self.c) and (self.c[0].level == 'series' or (self.c[0].c and self.c[0].c[0])):
            return True
        else:
            return False
1296428
async def series(self):
    '''
    '''
    items = []
    for i in await self.items:
      if i.type == 'Series':
        items.append(i)
      elif hasattr(i, 'series'):
        items.extend(await i.series)
    return items
456210
def episode_list(a):
    """"""
    html = get_html(ROOT + a.get('href'))
    div = html.find('div', {'class': "list detail eplist"})
    links = []
    for tag in div.find_all('a', {'itemprop': "name"}):
        links.append(tag)
    return links
1250554
public ResultList<Video> getEpisodeVideos(int tvID, int seasonNumber, int episodeNumber, String language) throws MovieDbException {
        return tmdbEpisodes.getEpisodeVideos(tvID, seasonNumber, episodeNumber, language);
    }
47003
def get_series(self, *args, **kwargs):
        
        from .series import Series, SeriesDataWrapper
        return self.get_related_resource(Series, SeriesDataWrapper, args, kwargs)