Engine.synclibrary() - Code Metrics - Inspection of "/fetchlibrary: Progress Dialog" - SIMKL/script.simkl - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — feature/fetchlibrary (0a4b7d)

by David

created 2017-02-12 00:16 UTC

Engine.synclibrary() F

↳ Parent: Engine

Complexity

Conditions

Size

Total Lines

134

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
cc	13
c	3
b	1
f	0
dl	0
loc	134
rs	2

How to fix Long Method Complexity

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import xbmc
import interface
import json
__addon__ = interface.__addon__
def getstr(strid): return interface.getstr(strid)

class Engine:
  def __init__(self, api, player):
    self.api = api
    self.player = player
    player.engine = self
    player.api    = api

  def synclibrary(self, mode="quick"):
    """
      Fetches the library from Simkl to Kodi
      Mode can be "quick" or "full"
    """
    xbmc.log("Simkl: Syncing library (Simkl to Kodi)")

    mode = "full"

    if mode == "full":
      todump = {
        "jsonrpc": "2.0",
        "method": "VideoLibrary.GetMovies",
        "params": {
          "limits": {
            "start": 0,
            "end": 1000
          },
          "properties": [
            "playcount",
            "imdbnumber",
            "file",
            "lastplayed",
            "year"
          ],
          "sort": {
            "order": "ascending",
            "method": "playcount",
            #"ignorearticle": True
          }
        },
        "id": "libMovies"
      }
      kodilibrary = json.loads(xbmc.executeJSONRPC(json.dumps(todump)))
      if kodilibrary["result"]["limits"]["total"] > 0:
        xbmc.log(str(kodilibrary))
        progress = interface.SyncProgress("movies", "full")
        each = float(100) / kodilibrary["result"]["limits"]["total"]
        for movie in kodilibrary["result"]["movies"]:
          progress.push(each, "{0} ({1})".format(movie["label"], movie["year"]))
          if movie["playcount"] == 0:
            ### DOWNLOAD FROM KODI
            #Separate big list in chunks
            movie["media"] = "movie"
            if self.api.check_if_watched(movie):
              xbmc.log("Simkl: {0}".format(movie))
              ret = xbmc.executeJSONRPC(json.dumps({
                  "jsonrpc": "2.0",
                  "method": "VideoLibrary.SetMovieDetails",
                  "params": {
                    "playcount": 1,
                    #"lastplayed":"",
                    "movieid":movie["movieid"]
                  }
                }))
              #xbmc.log(ret)
        del progress

      todump["method"] = "VideoLibrary.GetTVShows"
      todump["params"]["properties"] = ["imdbnumber", "title", "watchedepisodes"]
      #If watchedepisodes > 0
      kodilibrary = xbmc.executeJSONRPC(json.dumps(todump))
      kodilibrary = json.loads(kodilibrary)

      if kodilibrary["result"]["limits"]["total"] > 0:
        progress = interface.SyncProgress("TV Shows", "full")
        each = float(100) / kodilibrary["result"]["limits"]["total"]
        debug_cnt = 0
        for tvshow in kodilibrary["result"]["tvshows"]:
          #if debug_cnt >= 10: break #I have a lot of TV Shows, only for testing
          progress.push(each, tvshow["label"])
          debug_cnt += 1


          todump["method"] = "VideoLibrary.GetSeasons"
          #todump["params"]["Library.Id"] = tvshow["tvshowid"]
          todump["id"] = tvshow["tvshowid"]
          todump["params"]["properties"] = ["season", "episode", "watchedepisodes", "showtitle"]
          seasons = xbmc.executeJSONRPC(json.dumps(todump))
          xbmc.log(json.dumps(tvshow))
          xbmc.log(seasons)
          seasons = json.loads(seasons)


          for season in seasons["result"]["seasons"]:
            values = []

            todump["method"] = "VideoLibrary.GetEpisodes"
            todump["params"]["tvshowid"] = tvshow["tvshowid"]
            todump["params"]["season"] = season["season"]
            todump["params"]["properties"] = ["title", "rating", "playcount",
              "season", "episode", "showtitle", "lastplayed", "tvshowid"]

            episodes = xbmc.executeJSONRPC(json.dumps(todump))
            xbmc.log(episodes)
            episodes = json.loads(episodes)

            if episodes["result"]["limits"]["total"] > 0:
              for episode in episodes["result"]["episodes"]:
                values.append({
                    "type": "tv",
                    "season": episode["season"],
                    "episode": episode["episode"],
                    "title": episode["showtitle"],
                    "tvdb": tvshow["imdbnumber"]
                })

              watched = self.api.check_if_watched(values, False)
              xbmc.log(json.dumps(watched))

              for i, episode in enumerate(episodes["result"]["episodes"]):
                toupdate = {
                  "jsonrpc": "2.0",
                  "method": "VideoLibrary.SetEpisodeDetails",
                  "params": {
                    "episodeid":episode["episodeid"],
                    "playcount": int(watched[i]["result"]),
                  },
                  "id": "libMovies"
                }
                try:
                  toupdate["params"]["lastplayed"] = watched[i]["last_watched"]
                except KeyError:
                  toupdate["params"]["lastplayed"] = ""

                info = xbmc.executeJSONRPC(json.dumps(toupdate))
                xbmc.log("Simkl: Info: {0}".format(info))

            del todump["params"]["tvshowid"]
            del todump["params"]["season"]
          del progress

    xbmc.log("Simkl: Finished syncing library")
    interface.notify("Finished syncing library")


class Player(xbmc.Player):
  """ Replaces the Kodi player class """
  def __init__(self):
    xbmc.Player.__init__(self)

  @staticmethod
  def getMediaType():
    """ Returns the MediaType of the file currently playing """
    if xbmc.getCondVisibility('Container.Content(tvshows)'):
      return "show"
    elif xbmc.getCondVisibility('Container.Content(seasons)'):
      return "season"
    elif xbmc.getCondVisibility('Container.Content(episodes)'):
      return "episode"
    elif xbmc.getCondVisibility('Container.Content(movies)'):
      return "movie"
    else:
      return None

  def onPlayBackStarted(self):
    """ Activated at start """
    #self.onPlayBackStopped()
    pass
  def onPlayBackSeek(self, *args):
    """ Activated on seek """
    self.onPlayBackStopped()
  def onPlayBackResumed(self):
    """ Activated on resume """
    self.onPlayBackStopped()
  def onPlayBackEnded(self):
    """ Activated at end """
    xbmc.log("Simkl: ONPLAYBACKENDED")
    self.onPlayBackStopped()

  def onPlayBackStopped(self):
    """ Gets the info needed to pass to the api """
    try:
      movie = self.getVideoInfoTag()
      thing = xbmc.executeJSONRPC(json.dumps({
        "jsonrpc": "2.0",
        "method": "Player.GetItem",
        "params": {
          "properties": [ "showtitle", "title", "season", "episode", "file", "imdbnumber", "genre" ],
          "playerid": 1 },
        "id": "VideoGetItem"
      }))
      xbmc.log("Simkl: Full: {0}".format(thing))
      item = json.loads(thing)["result"]["item"]
      #imdb  = movie.getIMDBNumber().strip(" ")
      #fname = self.getPlayingFile()
      imdb = item["imdbnumber"]
      fname = item["file"]
      media = item["type"]
      xbmc.log("Simkl: IMDb: {0}".format(imdb))
      xbmc.log("Simkl: Genre: {0}".format(item["genre"]))
      xbmc.log("Simkl: MediaType: " + str(media))

      percentage = 100 * self.getTime() / self.getTotalTime()
      pctconfig  = int(self.addon.getSetting("scr-pct"))

      if 99 > percentage > pctconfig:
        bubble = __addon__.getSetting("bubble")
        xbmc.log("Simkl: Bubble == {0}".format(bubble))
        xbmc.log("Percentage: {0}, pctconfig {1}".format(percentage, pctconfig))

        xbmc.log("Simkl: Ready to scrobble {0}".format(movie.getTitle()))
        if imdb == "":
        #if True:
          xbmc.log("Simkl: No imdb - Fname: {0}".format(fname))
          r = self.api.watched(fname, media, self.getTotalTime())
        else:
          xbmc.log("Simkl: IMDB: " + str(imdb))
          r = self.api.watched(imdb, media, self.getTotalTime())

        if bubble=="true" and r:
          if item["label"] in item["file"]:
          #if True: #For testing purposes
            xbmc.log("Simkl: Label and file are the same")
            lstw = self.api.lastwatched
            if lstw["type"] == "episode":
              item["showtitle"] = lstw["show"]["title"]
              item["season"] = lstw["episode"]["season"]
              item["episode"] = lstw["episode"]["episode"]
            elif lstw["type"] == "movie":
              item["title"] = "".join([lstw["movie"]["title"], " (", str(lstw["movie"]["year"]), ")"])
            media = lstw["type"]

          txt = item["label"]
          title = ""
          if media == "movie":
            txt = item["title"]
          elif media == "episode":
            txt = item["showtitle"]
            title = "- S{:02}E{:02}".format(item["season"], item["episode"])
          xbmc.log("Simkl: " + "; ".join([media, txt, title]))
          interface.notify(getstr(32028).format(title), title=txt)
          r = 0

    except RuntimeError:
      pass
    except ZeroDivisionError:
      self.onPlayBackStopped()


1			#!/usr/bin/python
2			# -- coding: UTF-8 --
3
4			import xbmc
5			import interface
6			import json
7			__addon__ = interface.__addon__
8			def getstr(strid): return interface.getstr(strid)
9
10			class Engine:
11			def __init__(self, api, player):
12			self.api = api
13			self.player = player
14			player.engine = self
15			player.api = api
16
17			def synclibrary(self, mode="quick"):
18			"""
19			Fetches the library from Simkl to Kodi
20			Mode can be "quick" or "full"
21			"""
22			xbmc.log("Simkl: Syncing library (Simkl to Kodi)")
23
24			mode = "full"
25
26			if mode == "full":
27			todump = {
28			"jsonrpc": "2.0",
29			"method": "VideoLibrary.GetMovies",
30			"params": {
31			"limits": {
32			"start": 0,
33			"end": 1000
34			},
35			"properties": [
36			"playcount",
37			"imdbnumber",
38			"file",
39			"lastplayed",
40			"year"
41			],
42			"sort": {
43			"order": "ascending",
44			"method": "playcount",
45			#"ignorearticle": True
46			}
47			},
48			"id": "libMovies"
49			}
50			kodilibrary = json.loads(xbmc.executeJSONRPC(json.dumps(todump)))
51			if kodilibrary["result"]["limits"]["total"] > 0:
52			xbmc.log(str(kodilibrary))
53			progress = interface.SyncProgress("movies", "full")
54			each = float(100) / kodilibrary["result"]["limits"]["total"]
55			for movie in kodilibrary["result"]["movies"]:
56			progress.push(each, "{0} ({1})".format(movie["label"], movie["year"]))
57			if movie["playcount"] == 0:
58			### DOWNLOAD FROM KODI
59			#Separate big list in chunks
60			movie["media"] = "movie"
61			if self.api.check_if_watched(movie):
62			xbmc.log("Simkl: {0}".format(movie))
63			ret = xbmc.executeJSONRPC(json.dumps({
64			"jsonrpc": "2.0",
65			"method": "VideoLibrary.SetMovieDetails",
66			"params": {
67			"playcount": 1,
68			#"lastplayed":"",
69			"movieid":movie["movieid"]
70			}
71			}))
72			#xbmc.log(ret)
73			del progress
74
75			todump["method"] = "VideoLibrary.GetTVShows"
76			todump["params"]["properties"] = ["imdbnumber", "title", "watchedepisodes"]
77			#If watchedepisodes > 0
78			kodilibrary = xbmc.executeJSONRPC(json.dumps(todump))
79			kodilibrary = json.loads(kodilibrary)
80
81			if kodilibrary["result"]["limits"]["total"] > 0:
82			progress = interface.SyncProgress("TV Shows", "full")
83			each = float(100) / kodilibrary["result"]["limits"]["total"]
84			debug_cnt = 0
85			for tvshow in kodilibrary["result"]["tvshows"]:
86			#if debug_cnt >= 10: break #I have a lot of TV Shows, only for testing
87			progress.push(each, tvshow["label"])
88			debug_cnt += 1
89
90
91			todump["method"] = "VideoLibrary.GetSeasons"
92			#todump["params"]["Library.Id"] = tvshow["tvshowid"]
93			todump["id"] = tvshow["tvshowid"]
94			todump["params"]["properties"] = ["season", "episode", "watchedepisodes", "showtitle"]
95			seasons = xbmc.executeJSONRPC(json.dumps(todump))
96			xbmc.log(json.dumps(tvshow))
97			xbmc.log(seasons)
98			seasons = json.loads(seasons)
99
100
101			for season in seasons["result"]["seasons"]:
102			values = []
103
104			todump["method"] = "VideoLibrary.GetEpisodes"
105			todump["params"]["tvshowid"] = tvshow["tvshowid"]
106			todump["params"]["season"] = season["season"]
107			todump["params"]["properties"] = ["title", "rating", "playcount",
108			"season", "episode", "showtitle", "lastplayed", "tvshowid"]
109
110			episodes = xbmc.executeJSONRPC(json.dumps(todump))
111			xbmc.log(episodes)
112			episodes = json.loads(episodes)
113
114			if episodes["result"]["limits"]["total"] > 0:
115			for episode in episodes["result"]["episodes"]:
116			values.append({
117			"type": "tv",
118			"season": episode["season"],
119			"episode": episode["episode"],
120			"title": episode["showtitle"],
121			"tvdb": tvshow["imdbnumber"]
122			})
123
124			watched = self.api.check_if_watched(values, False)
125			xbmc.log(json.dumps(watched))
126
127			for i, episode in enumerate(episodes["result"]["episodes"]):
128			toupdate = {
129			"jsonrpc": "2.0",
130			"method": "VideoLibrary.SetEpisodeDetails",
131			"params": {
132			"episodeid":episode["episodeid"],
133			"playcount": int(watched[i]["result"]),
134			},
135			"id": "libMovies"
136			}
137			try:
138			toupdate["params"]["lastplayed"] = watched[i]["last_watched"]
139			except KeyError:
140			toupdate["params"]["lastplayed"] = ""
141
142			info = xbmc.executeJSONRPC(json.dumps(toupdate))
143			xbmc.log("Simkl: Info: {0}".format(info))
144
145			del todump["params"]["tvshowid"]
146			del todump["params"]["season"]
147			del progress
148
149			xbmc.log("Simkl: Finished syncing library")
150			interface.notify("Finished syncing library")
151
152
153			class Player(xbmc.Player):
154			""" Replaces the Kodi player class """
155			def __init__(self):
156			xbmc.Player.__init__(self)
157
158			@staticmethod
159			def getMediaType():
160			""" Returns the MediaType of the file currently playing """
161			if xbmc.getCondVisibility('Container.Content(tvshows)'):
162			return "show"
163			elif xbmc.getCondVisibility('Container.Content(seasons)'):
164			return "season"
165			elif xbmc.getCondVisibility('Container.Content(episodes)'):
166			return "episode"
167			elif xbmc.getCondVisibility('Container.Content(movies)'):
168			return "movie"
169			else:
170			return None
171
172			def onPlayBackStarted(self):
173			""" Activated at start """
174			#self.onPlayBackStopped()
175			pass
176			def onPlayBackSeek(self, *args):
177			""" Activated on seek """
178			self.onPlayBackStopped()
179			def onPlayBackResumed(self):
180			""" Activated on resume """
181			self.onPlayBackStopped()
182			def onPlayBackEnded(self):
183			""" Activated at end """
184			xbmc.log("Simkl: ONPLAYBACKENDED")
185			self.onPlayBackStopped()
186
187			def onPlayBackStopped(self):
188			""" Gets the info needed to pass to the api """
189			try:
190			movie = self.getVideoInfoTag()
191			thing = xbmc.executeJSONRPC(json.dumps({
192			"jsonrpc": "2.0",
193			"method": "Player.GetItem",
194			"params": {
195			"properties": [ "showtitle", "title", "season", "episode", "file", "imdbnumber", "genre" ],
196			"playerid": 1 },
197			"id": "VideoGetItem"
198			}))
199			xbmc.log("Simkl: Full: {0}".format(thing))
200			item = json.loads(thing)["result"]["item"]
201			#imdb = movie.getIMDBNumber().strip(" ")
202			#fname = self.getPlayingFile()
203			imdb = item["imdbnumber"]
204			fname = item["file"]
205			media = item["type"]
206			xbmc.log("Simkl: IMDb: {0}".format(imdb))
207			xbmc.log("Simkl: Genre: {0}".format(item["genre"]))
208			xbmc.log("Simkl: MediaType: " + str(media))
209
210			percentage = 100 * self.getTime() / self.getTotalTime()
211			pctconfig = int(self.addon.getSetting("scr-pct"))
212
213			if 99 > percentage > pctconfig:
214			bubble = __addon__.getSetting("bubble")
215			xbmc.log("Simkl: Bubble == {0}".format(bubble))
216			xbmc.log("Percentage: {0}, pctconfig {1}".format(percentage, pctconfig))
217
218			xbmc.log("Simkl: Ready to scrobble {0}".format(movie.getTitle()))
219			if imdb == "":
220			#if True:
221			xbmc.log("Simkl: No imdb - Fname: {0}".format(fname))
222			r = self.api.watched(fname, media, self.getTotalTime())
223			else:
224			xbmc.log("Simkl: IMDB: " + str(imdb))
225			r = self.api.watched(imdb, media, self.getTotalTime())
226
227			if bubble=="true" and r:
228			if item["label"] in item["file"]:
229			#if True: #For testing purposes
230			xbmc.log("Simkl: Label and file are the same")
231			lstw = self.api.lastwatched
232			if lstw["type"] == "episode":
233			item["showtitle"] = lstw["show"]["title"]
234			item["season"] = lstw["episode"]["season"]
235			item["episode"] = lstw["episode"]["episode"]
236			elif lstw["type"] == "movie":
237			item["title"] = "".join([lstw["movie"]["title"], " (", str(lstw["movie"]["year"]), ")"])
238			media = lstw["type"]
239
240			txt = item["label"]
241			title = ""
242			if media == "movie":
243			txt = item["title"]
244			elif media == "episode":
245			txt = item["showtitle"]
246			title = "- S{:02}E{:02}".format(item["season"], item["episode"])
247			xbmc.log("Simkl: " + "; ".join([media, txt, title]))
248			interface.notify(getstr(32028).format(title), title=txt)
249			r = 0
250
251			except RuntimeError:
252			pass
253			except ZeroDivisionError:
254			self.onPlayBackStopped()
255

SIMKL / script.simkl

GitHub Access Token became invalid

Branch — feature/fetchlibrary (0a4b7d)

Engine.synclibrary() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like