Exemplo n.º 1
0
def test_movie_to_json():
    tron = Movie('Tron Legacy', year=2010)
    expected = {'movies': [{'title': tron.title,
                            'year': 2010,
                            'ids': {'imdb': 'tt1104001',
                                    'slug': 'tron-legacy-2010',
                                    'tmdb': 20526,
                                    'trakt': 343}}]}
    assert tron.to_json() == expected
Exemplo n.º 2
0
def get_watched(list_type=None, extended=None):
    """Return all movies or shows a user has watched sorted by most plays.

    :param list_type: Optional Filter by a specific type.
        Possible values: movies, shows, seasons or episodes.
    :param extended: Optional value for requesting extended information.
    """
    valid_type = ('movies', 'shows', 'seasons', 'episodes')

    if list_type and list_type not in valid_type:
        raise ValueError('list_type must be one of {}'.format(valid_type))

    uri = 'sync/watchlist'
    if list_type:
        uri += '/{}'.format(list_type)

    if list_type == 'shows' and extended:
        uri += '?extended={extended}'.format(extended=extended)

    data = yield uri
    results = []
    for d in data:
        if 'movie' in d:
            from trakt.movies import Movie
            results.append(Movie(**d.pop('movie')))
        elif 'show' in d:
            from trakt.tv import TVShow
            results.append(TVShow(**d.pop('show')))

    yield results
Exemplo n.º 3
0
    def watching(self):
        """The :class:`TVEpisode` or :class:`Movie` this :class:`User` is
        currently watching. If they aren't watching anything, a blank object
        will be returned. Protected users won't return any data unless you are
        friends.
        """
        data = yield 'users/{user}/watching'.format(
            user=slugify(self.username))

        # if a user isn't watching anything, trakt returns a 204
        if data is None or data == '':
            yield None

        media_type = data.pop('type')
        if media_type == 'movie':
            movie_data = data.pop('movie')
            extract_ids(movie_data)
            movie_data.update(data)
            yield Movie(**movie_data)
        else:  # media_type == 'episode'
            ep_data = data.pop('episode')
            extract_ids(ep_data)
            sh_data = data.pop('show')
            ep_data.update(data, show=sh_data.get('title'))
            yield TVEpisode(**ep_data)
Exemplo n.º 4
0
def get_collection(list_type=None, extended=None):
    """
    Get all collected items in a user's collection.

    A collected item indicates availability to watch digitally
    or on physical media.

    :param list_type: Optional Filter by a specific type.
        Possible values: movies or shows.
    :param extended: Optional value for requesting extended information.
    """
    valid_type = ('movies', 'shows')

    if list_type and list_type not in valid_type:
        raise ValueError('list_type must be one of {}'.format(valid_type))

    uri = 'sync/watchlist'
    if list_type:
        uri += '/{}'.format(list_type)

    if extended:
        uri += '?extended={extended}'.format(extended=extended)

    data = yield uri
    results = []
    for d in data:
        if 'movie' in d:
            from trakt.movies import Movie
            results.append(Movie(**d.pop('movie')))
        elif 'show' in d:
            from trakt.tv import TVShow
            results.append(TVShow(**d.pop('show')))

    yield results
Exemplo n.º 5
0
def search_by_id(query, id_type='imdb', media_type=None):
    """Perform a search query by using a Trakt.tv ID or other external ID

    :param query: Your search string, which should be an ID from your source
    :param id_type: The source of the ID you're looking for. Must be one of
        'trakt', trakt-movie', 'trakt-show', 'trakt-episode', 'trakt-person',
        'imdb', 'tmdb', or 'tvdb'
    :param media_type: The type of media you're looking for. May be one of
        'movie', 'show', 'episode', or 'person', or a comma-separated list of
        any combination of those. Null by default, which will return all types
        of media that match the ID given.
    """
    valids = ('trakt', 'trakt-movie', 'trakt-show', 'trakt-episode',
              'trakt-person', 'imdb', 'tmdb', 'tvdb')
    id_types = {'trakt': 'trakt', 'trakt-movie': 'trakt',
                'trakt-show': 'trakt', 'trakt-episode': 'trakt',
                'trakt-person': 'trakt', 'imdb': 'imdb', 'tmdb': 'tmdb',
                'tvdb': 'tvdb'}
    if id_type not in valids:
        raise ValueError('search_type must be one of {}'.format(valids))
    source = id_types.get(id_type)

    media_types = {'trakt-movie': 'movie', 'trakt-show': 'show',
                   'trakt-episode': 'episode', 'trakt-person': 'person'}

    # If there was no media_type passed in, see if we can guess based off the
    # ID source. None is still an option here, as that will return all possible
    # types for a given source.
    if media_type is None:
        media_type = media_types.get(source, None)

    # If media_type is still none, don't add it as a parameter to the search
    if media_type is None:
        uri = 'search/{source}/{query}'.format(
            query=slugify(query), source=source)
    else:
        uri = 'search/{source}/{query}?type={media_type}'.format(
            query=slugify(query), source=source, media_type=media_type)
    data = yield uri

    for media_item in data:
        extract_ids(media_item)

    results = []
    for d in data:
        if 'episode' in d:
            from trakt.tv import TVEpisode
            show = d.pop('show')
            extract_ids(d['episode'])
            results.append(TVEpisode(show['title'], **d['episode']))
        elif 'movie' in d:
            from trakt.movies import Movie
            results.append(Movie(**d.pop('movie')))
        elif 'show' in d:
            from trakt.tv import TVShow
            results.append(TVShow(**d.pop('show')))
        elif 'person' in d:
            from trakt.people import Person
            results.append(Person(**d.pop('person')))
    yield results
Exemplo n.º 6
0
def search_by_id(query, id_type='imdb'):
    """Perform a search query by using a Trakt.tv ID or other external ID

    :param query: Your search string
    :param id_type: The type of object you're looking for. Must be one of
        'trakt-movie', 'trakt-show', 'trakt-episode', 'imdb', 'tmdb', 'tvdb' or
        'tvrage'
    """
    valids = ('trakt-movie', 'trakt-show', 'trakt-episode', 'imdb', 'tmdb',
              'tvdb', 'tvrage')
    if id_type not in valids:
        raise ValueError('search_type must be one of {}'.format(valids))
    data = yield 'search?id={query}&id_type={id_type}'.format(
        query=slugify(query), id_type=id_type)

    for media_item in data:
        extract_ids(media_item)

    results = []
    for d in data:
        if 'episode' in d:
            from trakt.tv import TVEpisode
            show = d.pop('show')
            extract_ids(d['episode'])
            results.append(TVEpisode(show['title'], **d['episode']))
        elif 'movie' in d:
            from trakt.movies import Movie
            results.append(Movie(**d.pop('movie')))
        elif 'show' in d:
            from trakt.tv import TVShow
            results.append(TVShow(**d.pop('show')))
        elif 'person' in d:
            from trakt.people import Person
            results.append(Person(**d.pop('person')))
    yield results
Exemplo n.º 7
0
 def _search(self, query, context=None):
     """Search for a movie matching *query*"""
     results = Movie.search(query)
     movie = self._filter_results(query, results)
     movie._get()  # fetch remainder of data from trakt
     if movie is not None:
         return self._apply_mapping(movie)
     return self.context
Exemplo n.º 8
0
def search(query, search_type='movie', year=None):
    """Perform a search query against all of trakt's media types

    :param query: Your search string
    :param search_type: The type of object you're looking for. Must be one of
        'movie', 'show', 'movie,show', 'episode', or 'person'
    """
    valids = ('movie', 'show', 'episode', 'person', 'movie,show')
    if search_type not in valids:
        raise ValueError('search_type must be one of {}'.format(valids))
    uri = 'search?query={query}&type={type}'.format(
        query=slugify(query), type=search_type)

    if year is not None:
        uri += '&year={}'.format(year)

    data = yield uri

    for media_item in data:
        extract_ids(media_item)

    # Need to do imports here to prevent circular imports with modules that
    # need to import Scrobblers
    if search_type == 'movie':
        from trakt.movies import Movie
        yield [Movie(d['score'], **d.pop('movie')) for d in data]
    elif search_type == 'show':
        from trakt.tv import TVShow
        yield [TVShow(d['score'], **d.pop('show')) for d in data]
    elif search_type == 'movie,show':
        from trakt.movies import Movie
        from trakt.tv import TVShow
        yield [Movie(d['score'], **d.pop('movie')) if d['type'] == 'movie'
               else TVShow(d['score'], **d.pop('show')) for d in data]
    elif search_type == 'episode':
        from trakt.tv import TVEpisode
        episodes = []
        for episode in data:
            show = episode.pop('show')
            extract_ids(episode['episode'])
            episodes.append(TVEpisode(show.get('title', None),
                                      **episode['episode']))
        yield episodes
    elif search_type == 'person':
        from trakt.people import Person
        yield [Person(**d.pop('person')) for d in data]
Exemplo n.º 9
0
def test_utilities():
    tron = Movie('Tron Legacy 2010')
    functions = [tron.add_to_library, tron.add_to_collection,
                 tron.add_to_watchlist, tron.dismiss, tron.mark_as_unseen,
                 tron.remove_from_library, tron.remove_from_collection,
                 tron.remove_from_watchlist, tron.mark_as_seen]
    for fn in functions:
        r = fn()
        assert r is None
Exemplo n.º 10
0
    def _build(self, data):
        """Build the calendar of Movies"""
        self._calendar = []
        for movie in data:
            m_data = movie.get('movie', {})
            released = movie.get('released', None)
            self._calendar.append(Movie(released=released, **m_data))

        self._calendar = sorted(self._calendar, key=lambda x: x.released)
Exemplo n.º 11
0
def test_movie_people():
    tron = Movie('Tron Legacy', year=2010)
    sub_groups = ['people', 'cast', 'crew']
    for group in sub_groups:
        persons = getattr(tron, group)
        assert isinstance(persons, list)
        assert len(persons) >= 1
        assert isinstance(persons[0], Person)
        assert all(isinstance(p, Person) for p in persons)
Exemplo n.º 12
0
def test_scrobble():
    """test the Scrobbler class's workflow"""
    guardians = Movie('Guardians of the Galaxy', year=2014)
    scrobbler = Scrobbler(guardians, 1.0, '1.0.0', '2015-02-01')
    scrobbler.start()
    scrobbler.update(50.0)
    scrobbler.pause()
    scrobbler.start()
    scrobbler.stop()
    scrobbler.start()
    scrobbler.finish()
Exemplo n.º 13
0
def test_get_movie():
    tron = Movie('Tron Legacy', year=2010)
    assert isinstance(tron, Movie)
    assert tron.title == 'TRON: Legacy'
    assert tron.year == 2010
    assert tron.tagline == 'The Game Has Changed.'
    assert tron.runtime == 125
    expected = {"trakt": 343,
                "slug": "tron-legacy-2010",
                "imdb": "tt1104001",
                "tmdb": 20526}
    assert tron.ids == {'ids': expected}
Exemplo n.º 14
0
 def watchlist_movies(self):
     """Returns all watchlist movies of :class:`User`.
     """
     if self._movie_watchlist is None:
         data = yield 'users/{username}/watchlist/movies'.format(
             username=slugify(self.username), )
         self._movie_watchlist = []
         for movie in data:
             mov = movie.pop('movie')
             extract_ids(mov)
             self._movie_watchlist.append(Movie(**mov))
         yield self._movie_watchlist
     yield self._movie_watchlist
Exemplo n.º 15
0
 def movie_collection(self):
     """All :class:`Movie`'s in this :class:`User`'s library collection.
     Collection items might include blu-rays, dvds, and digital downloads.
     Protected users won't return any data unless you are friends.
     """
     if self._movie_collection is None:
         ext = 'users/{username}/collection/movies?extended=metadata'
         data = yield ext.format(username=slugify(self.username))
         self._movie_collection = []
         for movie in data:
             mov = movie.pop('movie')
             extract_ids(mov)
             self._movie_collection.append(Movie(**mov))
     yield self._movie_collection
Exemplo n.º 16
0
 def watched_movies(self):
     """Watched profess for all :class:`Movie`'s in this :class:`User`'s
     collection.
     """
     if self._watched_movies is None:
         data = yield 'users/{user}/watched/movies'.format(
             user=slugify(self.username))
         self._watched_movies = []
         for movie in data:
             movie_data = movie.pop('movie')
             extract_ids(movie_data)
             movie_data.update(movie)
             self._watched_movies.append(Movie(**movie_data))
     yield self._watched_movies
Exemplo n.º 17
0
def get_search_results(query, search_type=None, slugify_query=False):
    """Perform a search query against all of trakt's media types.

    :param query: Your search string
    :param search_type: The types of objects you're looking for. Must be
        specified as a list of strings containing any of 'movie', 'show',
        'episode', or 'person'.
    :param slugify_query: A boolean indicating whether or not the provided
        query should be slugified or not prior to executing the query.
    """
    # if no search type was specified, then search everything
    if search_type is None:
        search_type = ['movie', 'show', 'episode', 'person']

    # If requested, slugify the query prior to running the search
    if slugify_query:
        query = slugify(query)

    uri = 'search/{type}?query={query}'.format(
        query=query, type=','.join(search_type))

    data = yield uri

    # Need to do imports here to prevent circular imports with modules that
    # need to import Scrobblers
    results = []
    for media_item in data:
        extract_ids(media_item)
        result = SearchResult(media_item['type'], media_item['score'])
        if media_item['type'] == 'movie':
            from trakt.movies import Movie
            result.media = Movie(**media_item.pop('movie'))
        elif media_item['type'] == 'show':
            from trakt.tv import TVShow
            result.media = TVShow(**media_item.pop('show'))
        elif media_item['type'] == 'episode':
            from trakt.tv import TVEpisode
            show = media_item.pop('show')
            result.media = TVEpisode(show.get('title', None),
                                     **media_item.pop('episode'))
        elif media_item['type'] == 'person':
            from trakt.people import Person
            result.media = Person(**media_item.pop('person'))
        results.append(result)

    yield results
Exemplo n.º 18
0
def get_watchlist(list_type=None, sort=None):
    """
    Get a watchlist.

    optionally with a filter for a specific item type.
    :param list_type: Optional Filter by a specific type.
        Possible values: movies, shows, seasons or episodes.
    :param sort: Optional sort. Only if the type is also sent.
        Possible values: rank, added, released or title.
    """
    valid_type = ('movies', 'shows', 'seasons', 'episodes')
    valid_sort = ('rank', 'added', 'released', 'title')

    if list_type and list_type not in valid_type:
        raise ValueError('list_type must be one of {}'.format(valid_type))

    if sort and sort not in valid_sort:
        raise ValueError('sort must be one of {}'.format(valid_sort))

    uri = 'sync/watchlist'
    if list_type:
        uri += '/{}'.format(list_type)

    if list_type and sort:
        uri += '/{}'.format(sort)

    data = yield uri
    results = []
    for d in data:
        if 'episode' in d:
            from trakt.tv import TVEpisode
            show = d.pop('show')
            extract_ids(d['episode'])
            results.append(TVEpisode(show, **d['episode']))
        elif 'movie' in d:
            from trakt.movies import Movie
            results.append(Movie(**d.pop('movie')))
        elif 'show' in d:
            from trakt.tv import TVShow
            results.append(TVShow(**d.pop('show')))

    yield results
Exemplo n.º 19
0
    def get_items(self):
        """A list of the list items using class instances
        instance types: movie, show, season, episode, person

        """

        data = yield 'users/{user}/lists/{id}/items'.format(user=slugify(
            self.creator),
                                                            id=self.slug)

        for item in data:
            # match list item type
            if 'type' not in item:
                continue
            item_type = item['type']
            item_data = item.pop(item_type)
            extract_ids(item_data)
            if item_type == 'movie':
                self._items.append(
                    Movie(item_data['title'], item_data['year'],
                          item_data['slug']))
            elif item_type == 'show':
                self._items.append(
                    TVShow(item_data['title'], item_data['slug']))
            elif item_type == 'season':
                show_data = item.pop('show')
                extract_ids(show_data)
                season = TVSeason(show_data['title'], item_data['number'],
                                  show_data['slug'])
                self._items.append(season)
            elif item_type == 'episode':
                show_data = item.pop('show')
                extract_ids(show_data)
                episode = TVEpisode(show_data['title'], item_data['season'],
                                    item_data['number'])
                self._items.append(episode)
            elif item_type == 'person':
                self._items.append(Person(item_data['name'],
                                          item_data['slug']))

        yield self._items
Exemplo n.º 20
0
 def do_trakt_search(self):
     """Search Trakt.TV for data on the movie being tagged"""
     self._update_progress()
     title = self.atoms['Name']
     year = None
     if '(' in title and ')' in title:
         year = title[title.find('(')+1:title.find(')')].strip()
         title = ' '.join(title.split()[:-1]).strip()
     movie = Movie(title, year=year)
     self.subler.rating = movie.certification
     self.atoms['Genre'] = movie.genres[0].name
     self.atoms['Description'] = self.atoms['Long Description'] = \
         movie.overview
     self.atoms['Release Date'] = movie.released_iso
     self.atoms['Name'] = movie.title
     if 'Artwork' not in self.atoms and 'poster' in movie.images:
         if self.has_artwork(movie.images['poster']):
             pid = str(os.getpid())
             art = os.path.abspath('.albumart{}.jpg'.format(pid))
             self.atoms['Artwork'] = art.replace(' ', '\\ ')
     self._update_progress()
Exemplo n.º 21
0
 def get_trakt_info(self, eiga_movie):
     logging.debug('search trakt for movie %s', eiga_movie['title_jp'])
     original_title = eiga_movie['movie_data'].get('原題'.decode('utf8'), None)
     year = eiga_movie['movie_data'].get('製作年'.decode('utf8'), None)
     logging.debug('search trakt for movie [%s](%s)', original_title, year)
     if original_title is None:
         logging.warning('original title does not exist, skip get trakt info')
         return None
     else:
         if year is not None:
             year = year[:4]
     try:
         result = Movie.search(original_title, year)
         if len(result) > 0:
             return result[0]
         else:
             return None
     except TypeError as e:
         logging.error('the movie title only contains non-ascii character, '
                       'PyTrakt can not handle this: %s' % title)
         return None
Exemplo n.º 22
0
def test_movie_comment():
    tron = Movie('Tron Legacy 2010')
    r = tron.comment('Some comment data')
    assert r is None
Exemplo n.º 23
0
def test_scrobbler_context_manager():
    """test the Scrobbler when used as a context manager"""
    guardians = Movie('Guardians of the Galaxy', year=2014)
    with Scrobbler(guardians, 0.0, '1.0.0', '2015-02-01') as scrob:
        for i in range(10):
            scrob.update(i * 10)
Exemplo n.º 24
0
def test_movie_translations():
    tron = Movie('Tron Legacy', year=2010)
    translations = tron.get_translations(country_code='es')
    assert isinstance(translations, list)
    assert len(translations) == 3
    assert isinstance(translations[0], Translation)
Exemplo n.º 25
0
def test_movie_comments():
    tron = Movie('Tron Legacy 2010')
    assert isinstance(tron.comments, list)
    assert len(tron.comments) == 1
    assert isinstance(tron.comments[0], Comment)
Exemplo n.º 26
0
def test_movie_ratings():
    tron = Movie('Tron Legacy 2010')
    assert isinstance(tron.ratings, dict)
Exemplo n.º 27
0
def test_movie_translations():
    tron = Movie('Tron Legacy', year=2010)
    translations = tron.get_translations(country_code='es')
    assert isinstance(translations, list)
    assert len(translations) == 3
    assert isinstance(translations[0], Translation)
Exemplo n.º 28
0
def test_movie_releases():
    tron = Movie('Tron Legacy 2010')
    releases = tron.get_releases()
    assert isinstance(releases, list)
    assert len(releases) == 13
    assert isinstance(releases[0], Release)
Exemplo n.º 29
0
 def _extract_media(self, media):
     from trakt.movies import Movie
     data = media.get(self.MEDIA_KEY)
     return Movie(**data)
 def com_net_trakt_set_rating_movie(self, movie_name_year, media_rating):
     """
     Set user rating on media
     """
     media_instance = Movie(movie_name_year)
     media_instance.rate(media_rating)
Exemplo n.º 31
0
def test_movie_related():
    tron = Movie('Tron Legacy', year=2010)
    assert isinstance(tron.related, list)
    assert len(tron.related) == 10
    assert isinstance(tron.related[0], Movie)
 def com_net_trakt_add_movie(self, movie_name_year):
     """
     Set add media
     """
     media_instance = Movie(movie_name_year)
     media_instance.add_to_library()
Exemplo n.º 33
0
def test_movie_watching():
    tron = Movie('Tron Legacy 2010')
    watching_now = tron.watching_now
    assert isinstance(watching_now, list)
    assert len(watching_now) == 2
    assert isinstance(watching_now[0], User)
Exemplo n.º 34
0
    def get_items(self):
        """A list of the list items using class instances
        instance types: movie, show, season, episode, person

        """

        data = yield 'users/{user}/lists/{id}/items'.format(user=self.creator,
                                                            id=self.slug)

        for item in data:
            # match list item type
            if 'type' not in item:
                continue
            item_type = item['type']
            item_data = item.pop(item_type)
            extract_ids(item_data)
            if item_type == 'movie':
                movie = Movie(item_data.pop('title'), item_data.pop('year'),
                              item_data.pop('slug'), **item_data)
                self._items.append(movie)
            elif item_type == 'show':
                show = TVShow(item_data.pop('title'),
                              slug=item_data.pop('slug'),
                              **item_data)
                seasons = show.seasons
                show._seasons = []
                for season in seasons:
                    season._episodes = []
                    show._seasons.append(season)
                self._items.append(show)
            elif item_type == 'season':
                show_data = item.pop('show')
                extract_ids(show_data)
                show = TVShow(show_data.pop('title'),
                              slug=show_data.pop('slug'),
                              **show_data)
                _season = TVSeason(show=show.title,
                                   season=item_data.pop('number'),
                                   slug=show.slug,
                                   **item_data)
                for season in show.seasons:
                    if season.trakt != _season.trakt:
                        continue
                    season._episodes = []
                    show._seasons = [season]
                    self._items.append(show)
                    break
                # season._episodes = []
                # show._seasons = [season]
                # self._items.append(show)

                # extract_ids(show_data)
                # show=TVShow(show_data['title'], show_data['slug'])
                # season = TVSeason(
                #     show=show.title,
                #     season=item_data['number'],
                #     slug=show.slug,
                #     **item_data
                # )
                # self._items.append(self.__class__.ListTVSeason(show=show, season=season))
            elif item_type == 'episode':
                show_data = item.pop('show')
                extract_ids(show_data)
                show = TVShow(show_data.pop('title'),
                              slug=show_data.pop('slug'),
                              **show_data)
                episode = TVEpisode(show=show.title,
                                    season=item_data.pop('season'),
                                    slug=show.slug,
                                    **item_data)
                for season in show.seasons:
                    if season.season != episode.season:
                        continue
                    season._episodes = [episode]
                    show._seasons = [season]
                    self._items.append(show)
                    break

                # show=TVShow(show_data['title'], show_data['slug'])
                # show._seasons = None
                # for season in show.seasons:
                #     if season.season != item_data['number']:
                #         continue
                #     episode = TVEpisode(show.title, season.season, item_data['number'], show.slug)
                #     self._items.append(self.__class__.ListTVEpisode(show=show, season=season, episode=episode))
                #     break
            elif item_type == 'person':
                self._items.append(Person(item_data['name'],
                                          item_data['slug']))

        yield self._items
Exemplo n.º 35
0
def test_rate_movie():
    tron = Movie('Tron Legacy 2010')
    tron.rate(10)
Exemplo n.º 36
0
def test_scrobble_movie():
    tron = Movie('Tron Legacy 2010')
    tron.scrobble(50.0, '1.0.0', '2015-02-01')
 def com_net_trakt_set_watching_movie(self, movie_name_year):
     """
     Set watching status on media
     """
     media_instance = Movie(movie_name_year)
     media_instance.watching_now()
Exemplo n.º 38
0
def test_movie_releases():
    tron = Movie('Tron Legacy 2010')
    releases = tron.get_releases()
    assert isinstance(releases, list)
    assert len(releases) == 13
    assert isinstance(releases[0], Release)
Exemplo n.º 39
0
def test_movie_to_json():
    tron = Movie('Tron Legacy', year=2010)
    assert tron.to_json() == {'movie': {'title': tron.title}}
Exemplo n.º 40
0
def test_movie_aliases():
    tron = Movie('Tron Legacy', year=2010)
    assert isinstance(tron.aliases, list)
    assert len(tron.aliases) == 15
Exemplo n.º 41
0
def test_movie_search():
    results = Movie.search('batman')
    assert isinstance(results, list)
    assert all(isinstance(m, Movie) for m in results)
 def com_net_trakt_set_seen_movie(self, movie_name_year):
     """
     Set seen status on media
     """
     media_instance = Movie(movie_name_year)
     media_instance.mark_as_seen()