コード例 #1
0
def processTvshows(habits, episodes, weighted, logged, item, freshness):
    # If this show has already been processed, pass
    if item['tvshowid'] in logged.keys():
        return
    logged[item["tvshowid"]] = "Processed"

    # If the show has been watched, do no more
    if item["watchedepisodes"] == item["episode"]:
        return

    # Get additional TMDB information
    keywords, related = sql.getTMDBExtras("episode", item["imdbnumber"],
                                          item["label"],
                                          item["premiered"][:-6])

    # Cut the year from the title
    title = item["title"]
    try:
        if title[:-6] == "(":
            title = title[:-7]
    except:
        pass

    # Work out the weighting
    weight = 0
    for key in habits.keys():
        weighting = getWeighting("episodes", key)
        for percentage, habit in habits[key]:
            for value in habit:
                value = value.decode("utf-8")
                if key == "mpaa":
                    # Check directly
                    if item['mpaa'] == value:
                        weight += (weighting / 100) * percentage

                if key == "tag":
                    # List
                    for tag in item["tag"]:
                        if tag == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["tag"]))

                if key == "studio":
                    # List
                    for studio in item["studio"]:
                        if studio == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["studio"]))

                if key == "genre":
                    # List
                    for genre in item["genre"]:
                        if genre == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["genre"]))

                if key == "actor":
                    for actor in item["cast"]:
                        if actor["name"] == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["cast"]))

                if key == "keyword":
                    if value in keywords:
                        weight += (weighting / 100) * percentage

                if key == "related":
                    if value == title.lower():
                        weight += (weighting / 100) * percentage

    # Prepare to get episode information
    nextUnwatched = None
    newest = None
    newestDate = "0"
    playedDate = "0"
    addNextUnwatched = True

    # Get hash
    itemHash = hashlib.md5(simplejson.dumps(item)).hexdigest()

    # If we already have the episode information...
    if item["tvshowid"] in tvshowInformation.keys() and tvshowInformation[
            item["tvshowid"]] == itemHash:
        # Retrieve previously saved next and newest episodes
        nextUnwatched = tvshowNextUnwatched[item["tvshowid"]]
        newest = tvshowNewest[item["tvshowid"]]

    else:
        # Get all episodes
        episode_query = xbmc.executeJSONRPC(
            '{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"tvshowid": %d, "properties": ["title", "playcount", "plot", "season", "episode", "showtitle", "file", "lastplayed", "rating", "resume", "art", "streamdetails", "firstaired", "runtime", "writer", "cast", "dateadded"], "sort": {"method": "episode"}}, "id": 1}'
            % item['tvshowid'])
        episode_query = unicode(episode_query, 'utf-8', errors='ignore')
        episode_query = simplejson.loads(episode_query)
        xbmc.sleep(100)

        # Find the next unwatched and the newest added episodes
        if episode_query.has_key("result") and episode_query["result"].has_key(
                "episodes"):
            for episode in episode_query["result"]["episodes"]:
                # Skip the episode if its the last played
                if _playingNow("episode", int(episode["episodeid"])):
                    continue
                #if lastplayedID is not None and lastplayedType == "episode":
                #    if int( episode[ "episodeid" ] ) == int( lastplayedID ):
                #        continue
                if episode["playcount"] == 0:
                    if addNextUnwatched:
                        # Next unwatched episode after most recently played we've found
                        nextUnwatched = episode
                        addNextUnwatched = False
                    if episode["dateadded"] > newestDate:
                        # This episode is newer than any we've previously found
                        newestDate = episode["dateadded"]
                        newest = episode
                elif episode["lastplayed"] > playedDate:
                    # We've watched this episode more recently than any we've previously found
                    playedDate = episode["lastplayed"]
                    addNextUnwatched = True

            # Save these for future runs
            tvshowInformation[item["tvshowid"]] = itemHash
            tvshowNextUnwatched[item["tvshowid"]] = nextUnwatched
            tvshowNewest[item["tvshowid"]] = newest
        else:
            log("No episodes returned for tv show " + item["tvshowid"])

    # If we didn't find any episodes, return
    if nextUnwatched is None and newest is None:
        return

    # If both episodes are the same, just keep the newest
    if nextUnwatched == newest:
        nextUnwatched = None

    # Save the next unwatched, with an additional weighting of 10
    if nextUnwatched is not None:
        episodes[nextUnwatched['episodeid']] = nextUnwatched

        if weight not in weighted.keys():
            weighted[weight] = [nextUnwatched["episodeid"]]
        else:
            weighted[weight].append(nextUnwatched["episodeid"])

    # Save the newest episode, with additional weighting on its new-ness
    if newest is not None:
        # Convert dateadded to a DateTime object
        dateadded = datetime.now() - datetime.strptime(newest["dateadded"],
                                                       "%Y-%m-%d %H:%M:%S")
        freshnessAddition = 0.00

        # How new is it
        if dateadded.days <= 2:
            if freshness[0] != 0 and weight != 0:
                freshnessAddition += (weight / 100.00) * freshness[0]
        elif dateadded.days <= 7:
            if freshness[1] != 0 and weight != 0:
                freshnessAddition += (weight / 100.00) * freshness[1]

        # If this isn't fresh/recent...
        if int(freshnessAddition) == 0:
            if nextUnwatched is None:
                # There's no next unwatched, so give this an additional weighting of 10
                freshnessAddition = 10
            else:
                # We already have a next unwatched, so we're done
                return

        episodes[newest['episodeid']] = newest

        if weight not in weighted.keys():
            weighted[weight] = [newest["episodeid"]]
        else:
            weighted[weight].append(newest["episodeid"])
コード例 #2
0
    def episode(self, json_query):
        # This function extracts the details we want to save from a tv show episode, and sends them to the addToDatabase function

        # First, time stamps (so all items have identical time stamp)
        dateandtime = str(datetime.now())
        time = str("%02d:%02d" % (datetime.now().hour, datetime.now().minute))
        day = datetime.today().weekday()

        # Save this as last played, so the widgets won't display it
        library.lastplayedType = "episode"
        library.lastplayedID = json_query["id"]
        library.tvshowInformation.pop(json_query["tvshowid"], None)
        library.tvshowNextUnwatched.pop(json_query["tvshowid"], None)
        library.tvshowNewest.pop(json_query["tvshowid"], None)
        self.episodeLastUpdated = 0
        self.lastEpisodeHabits = None

        # TV Show ID
        sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                          "episode", "tvshowid", json_query["tvshowid"])

        # Now get details of the tv show
        show_query = xbmc.executeJSONRPC(
            '{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShowDetails", "params": {"tvshowid": %s, "properties": ["sorttitle", "mpaa", "premiered", "episode", "watchedepisodes", "studio", "genre", "cast", "tag", "imdbnumber" ]}, "id": 1}'
            % json_query["tvshowid"])
        show_query = unicode(show_query, 'utf-8', errors='ignore')
        show_query = simplejson.loads(show_query)
        show_query = show_query["result"]["tvshowdetails"]

        # MPAA
        sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                          "episode", "mpaa", show_query["mpaa"])

        # Studio(s)
        for studio in show_query["studio"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "studio", studio)

        # Genre(s)
        for genre in show_query["genre"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "genre", genre)

        # Tag(s)
        for genre in show_query["tag"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "tag", tag)

        # Actor(s)
        for actor in show_query["cast"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "actor", actor["name"])

        # Is it watched
        if json_query["playcount"] == 0:
            # This is a new episode
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "special", "unwatched")

        # Get additional info from TMDB
        keywords, related = sql.getTMDBExtras("episode",
                                              json_query["imdbnumber"],
                                              show_query["label"],
                                              show_query["premiered"][:-6])
        for keyword in keywords:
            log("Adding keyword " + keyword)
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "keyword", keyword)
        for show in related:
            log("Adding related " + show)
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "related", show)

        # Convert dateadded to datetime object
        dateadded = datetime.now() - datetime.strptime(json_query["dateadded"],
                                                       "%Y-%m-%d %H:%M:%S")

        # How new is it
        if dateadded.days <= 2:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "special", "fresh")
        if dateadded.days <= 7:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "episode", "special", "recentlyadded")

        # Mark played, so we can get percentage unwatched/recent
        sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                          "episode", "special", "playedmedia")
コード例 #3
0
def processMovie(habits, movies, weighted, item, freshness):
    # If this movie has already been processed, pass
    if item['movieid'] in movies.keys():
        return

    # Save the movie
    movies[item['movieid']] = item

    # If the movie is current being watched, pass
    if _playingNow("movie", int(item["movieid"])):
        return
    #if lastplayedID is not None and lastplayedType == "movie":
    #    if int( item[ "movieid" ] ) == int( lastplayedID ):
    #        return

    # If this movie has been watched, pass
    if item['playcount'] >= 1:
        return

    # Cut the year from the title
    title = item["title"]
    try:
        if title[:-6] == "(":
            title = title[:-7]
    except:
        pass

    # Get additional TMDB information
    keywords, related = sql.getTMDBExtras("movie", item["imdbnumber"],
                                          item["title"], item["year"])

    # Work out the weighting
    weight = 0
    scores = []
    for key in habits.keys():
        # Get weighting
        weighting = getWeighting("movies", key)
        for percentage, habit in habits[key]:
            for value in habit:
                value = value.decode("utf-8")
                if key == "mpaa":
                    # Check directly
                    if item['mpaa'] == value:
                        weight += (weighting / 100) * percentage
                        scores.append("%s: %s (%f)" %
                                      (key, value,
                                       (weighting / 100) * percentage))

                if key == "tag":
                    # List
                    for tag in item["tag"]:
                        if value in tag:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["tag"]))
                            scores.append("%s: %s (%f)" %
                                          (key, value,
                                           ((weighting / 100) * percentage) /
                                           float(len(item["tag"]))))

                if key == "director":
                    # List
                    for director in item["director"]:
                        if director == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["director"]))
                            scores.append("%s: %s (%f)" %
                                          (key, value,
                                           ((weighting / 100) * percentage) /
                                           float(len(item["director"]))))

                if key == "writer":
                    # List
                    for writer in item["writer"]:
                        if writer == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["writer"]))
                            scores.append("%s: %s (%f)" %
                                          (key, value,
                                           ((weighting / 100) * percentage) /
                                           float(len(item["writer"]))))

                if key == "studio":
                    # List
                    for studio in item["studio"]:
                        if studio == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["studio"]))
                            scores.append("%s: %s (%f)" %
                                          (key, value,
                                           ((weighting / 100) * percentage) /
                                           float(len(item["studio"]))))

                if key == "genre":
                    # List
                    for genre in item["genre"]:
                        if genre == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["genre"]))
                            scores.append("%s: %s (%f)" %
                                          (key, value,
                                           ((weighting / 100) * percentage) /
                                           float(len(item["genre"]))))

                if key == "actor":
                    for actor in item["cast"]:
                        if actor["name"] == value:
                            weight += ((weighting / 100) * percentage) / float(
                                len(item["cast"]))
                            scores.append("%s: %s (%f)" %
                                          (key, value,
                                           ((weighting / 100) * percentage) /
                                           float(len(item["cast"]))))

                if key == "keyword":
                    if value in keywords:
                        weight += ((weighting / 100) * percentage) / float(
                            len(keywords))
                        scores.append("%s: %s (%f)" %
                                      (key, value,
                                       ((weighting / 100) * percentage) /
                                       float(len(keywords))))

                if key == "related":
                    if value == title.lower():
                        weight += (weighting / 100) * percentage
                        scores.append("%s: %s (%f)" %
                                      (key, value,
                                       (weighting / 100) * percentage))

    # Convert dateadded to a DateTime object
    dateadded = datetime.now() - datetime.strptime(item["dateadded"],
                                                   "%Y-%m-%d %H:%M:%S")
    freshnessAddition = 0.00

    # Add weighting dependant on fresh/recent
    if dateadded.days <= 2:
        if freshness[0] != 0 and weight != 0:
            freshnessAddition += (weight / 100.00) * freshness[0]
    elif dateadded.days <= 7:
        if freshness[1] != 0 and weight != 0:
            freshnessAddition += (weight / 100.00) * freshness[1]

    weight += int(freshnessAddition)

    if weight not in weighted.keys():
        weighted[weight] = [item["movieid"]]
    else:
        weighted[weight].append(item["movieid"])

    movieScores[item["movieid"]] = scores
コード例 #4
0
    def movie(self, json_query):
        # This function extracts the details we want to save from a movie, and sends them to the addToDatabase function

        # First, time stamps (so all items have identical time stamp)
        dateandtime = str(datetime.now())
        time = str("%02d:%02d" % (datetime.now().hour, datetime.now().minute))
        day = datetime.today().weekday()

        # Save this is lastplayed, so the widgets won't display it
        library.lastplayedType = "movie"
        library.lastplayedID = json_query["id"]
        self.movieLastUpdated = 0
        self.lastMovieHabits = None

        # MPAA
        if json_query["mpaa"] != "":
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "mpaa", json_query["mpaa"])

        # Tag
        for tag in json_query["tag"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "tag", tag)

        # Director(s)
        for director in json_query["director"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "director", director)

        # Writer(s)
        for writer in json_query["writer"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "writer", writer)

        # Studio(s)
        for studio in json_query["studio"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "studio", studio)

        # Genre(s)
        for genre in json_query["genre"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "genre", genre)

        # Actor(s)
        for actor in json_query["cast"]:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "actor", actor["name"])

        # Is it watched
        if json_query["playcount"] == 0:
            # This is a new movie
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "special", "unwatched")

        # Get additional info from TMDB
        keywords, related = sql.getTMDBExtras("movie", json_query["id"],
                                              json_query["imdbnumber"],
                                              json_query["year"])
        for keyword in keywords:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "keyword", keyword)
        for show in related:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "related", show)

        # Convert dateadded to datetime object
        dateadded = datetime.now() - datetime.strptime(json_query["dateadded"],
                                                       "%Y-%m-%d %H:%M:%S")

        # How new is it
        if dateadded.days <= 2:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "special", "fresh")
        if dateadded.days <= 7:
            sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                              "movie", "special", "recentlyadded")

        # Mark played, so we can get percentage unwatched/recent
        sql.addToDatabase(self.connectionWrite, dateandtime, time, day,
                          "movie", "special", "playedmedia")
コード例 #5
0
    def episode( self, json_query ):
        # This function extracts the details we want to save from a tv show episode, and sends them to the addToDatabase function
        
        # First, time stamps (so all items have identical time stamp)
        dateandtime = str( datetime.now() )
        time = str( "%02d:%02d" %( datetime.now().hour, datetime.now().minute ) )
        day = datetime.today().weekday()
                
        # Save this as last played, so the widgets won't display it
        library.lastplayedType = "episode"
        library.lastplayedID = json_query[ "id" ]
        library.tvshowInformation.pop( json_query[ "tvshowid" ], None )
        library.tvshowNextUnwatched.pop( json_query[ "tvshowid" ], None )
        library.tvshowNewest.pop( json_query[ "tvshowid" ], None )
        self.episodeLastUpdated = 0
        self.lastEpisodeHabits = None
        
        # TV Show ID
        sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "tvshowid", json_query[ "tvshowid" ] )
        
        # Now get details of the tv show
        show_query = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShowDetails", "params": {"tvshowid": %s, "properties": ["sorttitle", "mpaa", "premiered", "episode", "watchedepisodes", "studio", "genre", "cast", "tag", "imdbnumber" ]}, "id": 1}' % json_query[ "tvshowid" ] )
        show_query = unicode(show_query, 'utf-8', errors='ignore')
        show_query = simplejson.loads(show_query)
        show_query = show_query[ "result" ][ "tvshowdetails" ]
        
        # MPAA
        sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "mpaa", show_query[ "mpaa" ] )
            
        # Studio(s)
        for studio in show_query[ "studio" ]:
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "studio", studio )
            
        # Genre(s)
        for genre in show_query[ "genre" ]:
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "genre", genre )
            
        # Tag(s)
        for genre in show_query[ "tag" ]:
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "tag", tag )
        
        # Actor(s)
        for actor in show_query[ "cast" ]:
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "actor", actor[ "name" ] )

        # Is it watched
        if json_query[ "playcount" ] == 0:
            # This is a new episode
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "special", "unwatched" )
            
        # Get additional info from TMDB
        keywords, related = sql.getTMDBExtras( "episode", json_query[ "imdbnumber" ], show_query[ "label" ], show_query[ "premiered" ][:-6] )
        for keyword in keywords:
            log( "Adding keyword " + keyword )
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "keyword", keyword )
        for show in related:
            log( "Adding related " + show )
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "related", show )        
        
        # Convert dateadded to datetime object
        dateadded = datetime.now() - datetime.strptime( json_query[ "dateadded" ], "%Y-%m-%d %H:%M:%S" )
        
        # How new is it
        if dateadded.days <= 2:
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "special", "fresh" )
        if dateadded.days <= 7:
            sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "special", "recentlyadded" )
            
        # Mark played, so we can get percentage unwatched/recent
        sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "episode", "special", "playedmedia" )
コード例 #6
0
 def movie( self, json_query ):
     # This function extracts the details we want to save from a movie, and sends them to the addToDatabase function
     
     # First, time stamps (so all items have identical time stamp)
     dateandtime = str( datetime.now() )
     time = str( "%02d:%02d" %( datetime.now().hour, datetime.now().minute ) )
     day = datetime.today().weekday()
     
     # Save this is lastplayed, so the widgets won't display it
     library.lastplayedType = "movie"
     library.lastplayedID = json_query[ "id" ]
     self.movieLastUpdated = 0
     self.lastMovieHabits = None
     
     # MPAA
     if json_query[ "mpaa" ] != "":
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "mpaa", json_query[ "mpaa" ] )
     
     # Tag
     for tag in json_query[ "tag" ]:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "tag", tag )
     
     # Director(s)
     for director in json_query[ "director" ]:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "director", director )
         
     # Writer(s)
     for writer in json_query[ "writer" ]:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "writer", writer )
         
     # Studio(s)
     for studio in json_query[ "studio" ]:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "studio", studio )
         
     # Genre(s)
     for genre in json_query[ "genre" ]:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "genre", genre )
         
     # Actor(s)
     for actor in json_query[ "cast" ]:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "actor", actor[ "name" ] )
         
     # Is it watched
     if json_query[ "playcount" ] == 0:
         # This is a new movie
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "special", "unwatched" )
     
     # Get additional info from TMDB
     keywords, related = sql.getTMDBExtras( "movie", json_query[ "id" ], json_query[ "imdbnumber" ], json_query[ "year" ] )
     for keyword in keywords:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "keyword", keyword )
     for show in related:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "related", show )        
     
     # Convert dateadded to datetime object
     dateadded = datetime.now() - datetime.strptime( json_query[ "dateadded" ], "%Y-%m-%d %H:%M:%S" )
     
     # How new is it
     if dateadded.days <= 2:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "special", "fresh" )
     if dateadded.days <= 7:
         sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "special", "recentlyadded" )
         
     # Mark played, so we can get percentage unwatched/recent
     sql.addToDatabase( self.connectionWrite, dateandtime, time, day, "movie", "special", "playedmedia" )
コード例 #7
0
def processTvshows( habits, episodes, weighted, logged, item, freshness ):
    # If this show has already been processed, pass
    if item['tvshowid'] in logged.keys():
        return
    logged[ item[ "tvshowid" ] ] = "Processed"

    # If the show has been watched, do no more
    if item[ "watchedepisodes" ] == item[ "episode" ]:
        return

    # Get additional TMDB information
    keywords, related = sql.getTMDBExtras( "episode", item[ "imdbnumber" ], item[ "label" ], item[ "premiered" ][:-6] )

    # Cut the year from the title
    title = item[ "title" ]
    try:
        if title[:-6] == "(":
            title = title[:-7]
    except:
        pass

    # Work out the weighting
    weight = 0
    for key in habits.keys():
        weighting = getWeighting( "episodes", key )
        for percentage, habit in habits[ key ]:
            for value in habit:
                value = value.decode( "utf-8" )
                if key == "mpaa":
                    # Check directly
                    if item[ 'mpaa' ] == value:
                        weight += ( weighting / 100 ) * percentage

                if key == "tag":
                    # List
                    for tag in item[ "tag" ]:
                        if tag == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "tag" ] ) )

                if key == "studio":
                    # List
                    for studio in item[ "studio" ]:
                        if studio == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "studio" ] ) )

                if key == "genre":
                    # List
                    for genre in item[ "genre" ]:
                        if genre == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "genre" ] ) )

                if key == "actor":
                    for actor in item[ "cast" ]:
                        if actor[ "name" ] == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "cast" ] ) )

                if key == "keyword":
                    if value in keywords:
                        weight += ( weighting / 100 ) * percentage

                if key == "related":
                    if value == title.lower():
                        weight += ( weighting / 100 ) * percentage

    # Prepare to get episode information
    nextUnwatched = None
    newest = None
    newestDate = "0"
    playedDate = "0"
    addNextUnwatched = True

    # Get hash
    itemHash = hashlib.md5( simplejson.dumps( item ) ).hexdigest()

    # If we already have the episode information...
    if item[ "tvshowid" ] in tvshowInformation.keys() and tvshowInformation[ item[ "tvshowid" ] ] == itemHash:
        # Retrieve previously saved next and newest episodes
        nextUnwatched = tvshowNextUnwatched[ item[ "tvshowid" ] ]
        newest = tvshowNewest[ item[ "tvshowid" ] ]

    else:
        # Get all episodes
        episode_query = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"tvshowid": %d, "properties": ["title", "playcount", "plot", "season", "episode", "showtitle", "file", "lastplayed", "rating", "resume", "art", "streamdetails", "firstaired", "runtime", "writer", "cast", "dateadded"], "sort": {"method": "episode"}}, "id": 1}' %item['tvshowid'])
        episode_query = unicode(episode_query, 'utf-8', errors='ignore')
        episode_query = simplejson.loads(episode_query)
        xbmc.sleep( 100 )

        # Find the next unwatched and the newest added episodes
        if episode_query.has_key( "result" ) and episode_query[ "result" ].has_key( "episodes" ):
            for episode in episode_query[ "result" ][ "episodes" ]:
                # Skip the episode if its the last played
                if _playingNow( "episode", int( episode[ "episodeid" ] ) ):
                    continue
                #if lastplayedID is not None and lastplayedType == "episode":
                #    if int( episode[ "episodeid" ] ) == int( lastplayedID ):
                #        continue
                if episode[ "playcount" ] == 0:
                    if addNextUnwatched:
                        # Next unwatched episode after most recently played we've found
                        nextUnwatched = episode
                        addNextUnwatched = False
                    if episode[ "dateadded" ] > newestDate:
                        # This episode is newer than any we've previously found
                        newestDate = episode[ "dateadded" ]
                        newest = episode
                elif episode[ "lastplayed" ] > playedDate:
                    # We've watched this episode more recently than any we've previously found
                    playedDate = episode[ "lastplayed" ]
                    addNextUnwatched = True

            # Save these for future runs
            tvshowInformation[ item[ "tvshowid" ] ] = itemHash
            tvshowNextUnwatched[ item[ "tvshowid" ] ] = nextUnwatched
            tvshowNewest[ item[ "tvshowid" ] ] = newest
        else:
            log( "No episodes returned for tv show " + item[ "tvshowid" ] )

    # If we didn't find any episodes, return
    if nextUnwatched is None and newest is None:
        return

    # If both episodes are the same, just keep the newest
    if nextUnwatched == newest:
        nextUnwatched = None

    # Save the next unwatched, with an additional weighting of 10
    if nextUnwatched is not None:
        episodes[ nextUnwatched[ 'episodeid' ] ] = nextUnwatched

        if weight not in weighted.keys():
            weighted[ weight ] = [ nextUnwatched[ "episodeid" ] ]
        else:
            weighted[ weight ].append( nextUnwatched[ "episodeid" ] )

    # Save the newest episode, with additional weighting on its new-ness
    if newest is not None:
        # Convert dateadded to a DateTime object
        dateadded = datetime.now() - datetime.strptime( newest[ "dateadded" ], "%Y-%m-%d %H:%M:%S" )
        freshnessAddition = 0.00

        # How new is it
        if dateadded.days <= 2:
            if freshness[ 0 ] != 0 and weight != 0:
                freshnessAddition += ( weight / 100.00 ) * freshness[ 0 ]
        elif dateadded.days <= 7:
            if freshness[ 1 ] != 0 and weight != 0:
                freshnessAddition += ( weight / 100.00 ) * freshness[ 1 ]

        # If this isn't fresh/recent...
        if int( freshnessAddition) == 0:
            if nextUnwatched is None:
                # There's no next unwatched, so give this an additional weighting of 10
                freshnessAddition = 10
            else:
                # We already have a next unwatched, so we're done
                return

        episodes[ newest[ 'episodeid' ] ] = newest

        if weight not in weighted.keys():
            weighted[ weight ] = [ newest[ "episodeid" ] ]
        else:
            weighted[ weight ].append( newest[ "episodeid" ] )
コード例 #8
0
def processMovie( habits, movies, weighted, item, freshness ):
    # If this movie has already been processed, pass
    if item['movieid'] in movies.keys():
        return

    # Save the movie
    movies[ item['movieid'] ] = item

    # If the movie is current being watched, pass
    if _playingNow( "movie", int( item[ "movieid" ] ) ):
        return
    #if lastplayedID is not None and lastplayedType == "movie":
    #    if int( item[ "movieid" ] ) == int( lastplayedID ):
    #        return

    # If this movie has been watched, pass
    if item[ 'playcount' ] >= 1:
        return

    # Cut the year from the title
    title = item[ "title" ]
    try:
        if title[:-6] == "(":
            title = title[:-7]
    except:
        pass

    # Get additional TMDB information
    keywords, related = sql.getTMDBExtras( "movie", item[ "imdbnumber" ], item[ "title" ], item[ "year" ] )

    # Work out the weighting
    weight = 0
    scores = []
    for key in habits.keys():
        # Get weighting
        weighting = getWeighting( "movies", key )
        for percentage, habit in habits[ key ]:
            for value in habit:
                value = value.decode( "utf-8" )
                if key == "mpaa":
                    # Check directly
                    if item[ 'mpaa' ] == value:
                        weight += ( weighting / 100 ) * percentage
                        scores.append( "%s: %s (%f)" %( key, value, ( weighting / 100 ) * percentage ) )

                if key == "tag":
                    # List
                    for tag in item[ "tag" ]:
                        if value in tag:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "tag" ] ) )
                            scores.append( "%s: %s (%f)" %( key, value, ( ( weighting / 100 ) * percentage ) / float( len( item[ "tag" ] ) ) ) )

                if key == "director":
                    # List
                    for director in item[ "director" ]:
                        if director == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "director" ] ) )
                            scores.append( "%s: %s (%f)" %( key, value, ( ( weighting / 100 ) * percentage ) / float( len( item[ "director" ] ) ) ) )

                if key == "writer":
                    # List
                    for writer in item[ "writer" ]:
                        if writer == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "writer" ] ) )
                            scores.append( "%s: %s (%f)" %( key, value, ( ( weighting / 100 ) * percentage ) / float( len( item[ "writer" ] ) ) ) )

                if key == "studio":
                    # List
                    for studio in item[ "studio" ]:
                        if studio == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "studio" ] ) )
                            scores.append( "%s: %s (%f)" %( key, value, ( ( weighting / 100 ) * percentage ) / float( len( item[ "studio" ] ) ) ) )

                if key == "genre":
                    # List
                    for genre in item[ "genre" ]:
                        if genre == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "genre" ] ) )
                            scores.append( "%s: %s (%f)" %( key, value, ( ( weighting / 100 ) * percentage ) / float( len( item[ "genre" ] ) ) ) )

                if key == "actor":
                    for actor in item[ "cast" ]:
                        if actor[ "name" ] == value:
                            weight += ( ( weighting / 100 ) * percentage ) / float( len( item[ "cast" ] ) )
                            scores.append( "%s: %s (%f)" %( key, value, ( ( weighting / 100 ) * percentage ) / float( len( item[ "cast" ] ) ) ) )

                if key == "keyword":
                    if value in keywords:
                        weight += ( ( weighting / 100 ) * percentage ) / float( len( keywords ) )
                        scores.append( "%s: %s (%f)" %( key, value, ( ( weighting / 100 ) * percentage ) / float( len( keywords ) ) ) )

                if key == "related":
                    if value == title.lower():
                        weight += ( weighting / 100 ) * percentage
                        scores.append( "%s: %s (%f)" %( key, value, ( weighting / 100 ) * percentage ) )

    # Convert dateadded to a DateTime object
    dateadded = datetime.now() - datetime.strptime( item[ "dateadded" ], "%Y-%m-%d %H:%M:%S" )
    freshnessAddition = 0.00

    # Add weighting dependant on fresh/recent
    if dateadded.days <= 2:
        if freshness[ 0 ] != 0 and weight != 0:
            freshnessAddition += ( weight / 100.00 ) * freshness[ 0 ]
    elif dateadded.days <= 7:
        if freshness[ 1 ] != 0 and weight != 0:
            freshnessAddition += ( weight / 100.00 ) * freshness[ 1 ]

    weight += int( freshnessAddition )

    if weight not in weighted.keys():
        weighted[ weight ] = [ item[ "movieid" ] ]
    else:
        weighted[ weight ].append( item[ "movieid" ] )

    movieScores[ item[ "movieid" ] ] = scores