Returns information about an episode in a television series

        Maps to the `episode info <http://prod-doc.rovicorp.com/mashery/index.php/V1.MetaData.VideoService.Video:SeasonEpisode>`_ API method.
186541
def episode_info(self, cosmoid, season, episode, **kwargs):
        

        resource = 'season/%d/episode/%d/info' % (season, episode)

        return self._cosmoid_request(resource, cosmoid, **kwargs)
1250554
public ResultList<Video> getEpisodeVideos(int tvID, int seasonNumber, int episodeNumber, String language) throws MovieDbException {
        return tmdbEpisodes.getEpisodeVideos(tvID, seasonNumber, episodeNumber, language);
    }
559627
public Episode getEpisodeInfo(String showID, String seasonId, String episodeId) throws TVRageException {
        if (!isValidString(showID) || !isValidString(seasonId) || !isValidString(episodeId)) {
            return new Episode();
        }

        StringBuilder tvrageURL = buildURL(API_EPISODE_INFO, showID);
        // Append the Season & Episode to the URL
        tvrageURL.append("&ep=").append(seasonId);
        tvrageURL.append("x").append(episodeId);

        return TVRageParser.getEpisodeInfo(tvrageURL.toString());
    }
274165
private function getEpisode()
    {
        $episode = [];
        $episode_area = $this->_parser->find('.episode-video', 0);
        if ($episode_area) {
            foreach ($episode_area->find('.video-list-outer') as $v) {
                $temp = [];

                $link_area = $v->find('a', 0);
                $temp['episode'] = $this->getEpisodeTitle($link_area, 0);
                $temp['title'] = $this->getEpisodeTitle($link_area, 1);
                $temp['link'] = $link_area->href;

                $episode[] = $temp;
            }
        }

        return $episode;
    }
983088
def episode(number)
      episodes.detect { |epi| epi.index.to_i == number.to_i }
    end
1128652
def get_series_episode(series_id, season, episode):
    
    result = tvdb_client.query_series_episodes(series_id, aired_season=season, aired_episode=episode)
    if result:
        return tvdb_client.get_episode(result['data'][0]['id'])
1078540
public function get($episodeId): Episode
    {
        $json = $this->client->performApiCallWithJsonResponse('get', '/episodes/' . (int) $episodeId);
        return ResponseHandler::create($json, ResponseHandler::METHOD_EPISODE)->handle();
    }
90467
public function getClosureById(int $episodeId): Closure
    {
        return function ($language) use ($episodeId) {
            $json = $this->parent->performAPICallWithJsonResponse(
                'get',
                '/episodes/'.$episodeId,
                [
                    'headers' => ['Accept-Language' => $language]
                ]
            );
            return DataParser::parseData($json, Episode::class);
        };
    }
218213
public ResultList<Artwork> getEpisodeImages(int tvID, int seasonNumber, int episodeNumber) throws MovieDbException {
        return tmdbEpisodes.getEpisodeImages(tvID, seasonNumber, episodeNumber);
    }
1180484
def find_episode_by_airdate(series_id, airdate)
      base_url = "/GetEpisodeByAirDate.php"
      query_params = { :apikey => @api_key, :seriesid => series_id, :airdate => airdate  }
      result = self.class.get(base_url, :query => query_params)['Data']
      return nil unless result && result['Episode']
      Episode.new(self, result['Episode'])
    end
1262242
public function byId(int $episodeId): Episode
    {
        $json = $this->parent->performAPICallWithJsonResponse('get', '/episodes/'.$episodeId);
        return DataParser::parseData($json, Episode::class);
    }
433243
def parse(link):
    
    html = get_html(link)

    data = {'rating': get_rating(html),
            'name': get_name_date(html)[0]}

    div = html.find(id="title-episode-widget")
    season_tags = get_a(div, find="season=")
    episodes = {}
    for slink in season_tags:
        for e in episode_list(slink):
            season, d = parse_episode(e)
            if season in episodes:
                episodes[season].append(d)
            else:
                episodes[season] = [d]
    data['episodes'] = episodes
    return data
651775
private function getEpisode($producer_area)
    {
        $episode = $producer_area->find('div[class=eps]', 0)->plaintext;
        $episode = trim(str_replace(['eps', 'ep'], '', $episode));

        return $episode == '?' ? '' : $episode;
    }
406103
public ExternalID getEpisodeExternalID(int tvID, int seasonNumber, int episodeNumber, String language) throws MovieDbException {
        return tmdbEpisodes.getEpisodeExternalID(tvID, seasonNumber, episodeNumber, language);
    }
521123
public static function determineEpisodeImagePath($episode, $show) {
        if (empty($episode->featured_image)) {

            // I'm gonna be a very bad boy here and just return the cloudfront path,
            // because, at this point, LaSalleCast is just for moi, and I use AWS cloudfront

            return $show->featured_image;

            //return Config('app.url') .'/'. Config::get('lasallecastfrontend.images_shows') .'/'. $show->featured_image;
        }

        return $show->image_file_storage_url . $episode->featured_image;
    }
980988
def to_dict(self):
        

        result = super(Progress, self).to_dict()

        label = LABELS['last_progress_change'][self.progress_type]
        result[label] = to_iso8601_datetime(self.last_progress_change)

        if self.progress_type == 'watched':
            result['reset_at'] = self.reset_at

        result['seasons'] = [
            season.to_dict()
            for season in self.seasons.values()
        ]

        if self.hidden_seasons:
            result['hidden_seasons'] = [
                popitems(season.to_dict(), ['number', 'ids'])
                for season in self.hidden_seasons.values()
            ]

        if self.next_episode:
            result['next_episode'] = popitems(self.next_episode.to_dict(), ['season', 'number', 'title', 'ids'])
            result['next_episode']['season'] = self.next_episode.keys[0][0]

        if self.last_episode:
            result['last_episode'] = popitems(self.last_episode.to_dict(), ['season', 'number', 'title', 'ids'])
            result['last_episode']['season'] = self.last_episode.keys[0][0]

        return result
969901
@SuppressWarnings({"ConstantConditions"})
    private Map<String, String> buildEpisodeMap(String[] showIds, String[] episodeIds, String searchTerm,
                                                SearchType searchType, TagMode tagMode, Episode.EpisodeStatus status,
                                                SortBy sortBy, SortDir sortDir, Boolean includeViews, Integer page,
                                                Integer perPage, Integer embedWidth, Integer embedHeight) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("expires", expires());
        if (showIds != null) map.put("show_id", join(showIds));
        if (episodeIds != null) map.put("id", join(episodeIds));
        if (searchTerm != null) map.put("search_type", searchType.name());
        if (tagMode != null) map.put("tag_mode", tagMode.name());
        if (status != null) map.put("status", status.name());
        if (sortBy != null) map.put("sort_by", sortBy.name());
        if (sortDir != null) map.put("sort_dir", sortDir.name());
        if (includeViews != null) map.put("include_views", includeViews.toString());
        if (page != null) map.put("page", page.toString());
        if (perPage != null) map.put("per_page", perPage.toString());
        if (embedWidth != null) map.put("embed_width", embedWidth.toString());
        if (embedHeight != null) map.put("embed_height", embedHeight.toString());
        return map;
    }