def run_episodes(self): # Iterate over plex episodes for ids, guid, ( season_num, episode_num), p_show, p_season, p_episode in self.p_episodes: # Increment one step self.current.progress.group(Shows, 'matched:episodes').step() # Parse guid match = GuidParser.parse(guid, (season_num, episode_num)) if not match.supported: mark_unsupported(self.p_shows_unsupported, ids['show'], guid) continue if not match.found: log.info( 'Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, ids['show']) continue # Process episode self.run_episode(ids, match, p_show, p_season, p_episode) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'matched:episodes').stop()
def run(self): for mo_id, guid, p_item in self.p_movies: # Increment one step self.current.progress.group(Movies, 'matched:movies').step() # Parse guid match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_unsupported, mo_id, guid) continue if not match.found: log.info('Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, mo_id) continue # Retrieve primary key for item pk = self.trakt.table('movies').get((match.guid.service, match.guid.id)) # Process movie (execute handlers) self.execute_movie(mo_id, pk, match.guid, p_item) # Remove movie from pending items collection self.current.pending['movies'].remove(pk) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Movies, 'matched:movies').stop() # Report unsupported movies (unsupported guid) log_unsupported(log, 'Found %d unsupported movie(s)', self.p_unsupported)
def run_shows(self): # Iterate over plex shows for sh_id, guid, p_show in self.p_shows: # Increment one step self.current.progress.group(Shows, 'matched:shows').step() # Process `p_guid` (map + validate) match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_shows_unsupported, sh_id, guid) continue if not match.found: log.info('Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, sh_id) continue # Process show self.run_show(sh_id, match, p_show) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'matched:shows').stop()
def run_episodes(self): # Iterate over plex episodes for ids, guid, (season_num, episode_num), p_show, p_season, p_episode in self.p_episodes: # Increment one step self.current.progress.group(Shows, 'episodes').step() # Process `p_guid` (map + validate) match = GuidParser.parse(guid, (season_num, episode_num)) if not match.supported: mark_unsupported(self.p_shows_unsupported, ids['show'], guid) continue if not match.found: log.info('Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, ids['show']) continue # Process episode self.run_episode(ids, match, p_show, p_episode) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'episodes').stop()
def run_shows(self): # Iterate over plex shows for sh_id, guid, p_show in self.p_shows: # Increment one step self.current.progress.group(Shows, 'matched:shows').step() # Process `p_guid` (map + validate) match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_shows_unsupported, sh_id, guid) continue if not match.found: log.info( 'Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, sh_id) continue # Process show self.run_show(sh_id, match, p_show) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'matched:shows').stop()
def process_matched_episodes(self): # Iterate over plex episodes for ids, guid, (season_num, episode_num), p_show, p_season, p_episode in self.p_episodes: # Increment one step self.current.progress.group(Shows, 'matched:episodes').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_shows_unsupported, ids['show'], guid) continue key = (guid.service, guid.id) identifier = (season_num, episode_num) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) with elapsed.clock(Shows, 'run:plex_episodes:execute_handlers'): for data in self.get_data(SyncMedia.Episodes): with elapsed.clock(Shows, 'run:plex_episodes:t_objects'): t_show, t_season, t_episode = self.t_objects( self.trakt[(SyncMedia.Episodes, data)], pk, season_num, episode_num ) # Execute episode handlers self.execute_handlers( SyncMedia.Episodes, data, key=ids['episode'], identifier=identifier, guid=guid, p_show=p_show, p_item=p_episode, t_show=t_show, t_item=t_episode ) # Remove episode from `pending_episodes` if pk in self.p_episodes_pending and identifier in self.p_episodes_pending[pk]: self.p_episodes_pending[pk].remove(identifier) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'matched:episodes').stop()
def run(self): for mo_id, guid, p_movie in self.p_movies: # Parse guid match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_unsupported, mo_id, guid) continue if not match.found: log.info( 'Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, mo_id) continue key = (match.guid.service, match.guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_movie.get('library_section'), mo_id, [key, pk]) if pk is None: # No `pk` found continue # Execute data handlers for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers(self.mode, SyncMedia.Movies, data, key=mo_id, p_item=p_movie, t_item=t_movie) # Increment one step self.step(self.p_pending, data, pk) # Task checkpoint self.checkpoint() # Log details log_unsupported(log, 'Found %d unsupported movie(s)', self.p_unsupported) log.debug('Pending: %r', self.p_pending)
def process_matched_episodes(self): # Iterate over plex episodes for ids, guid, ( season_num, episode_num), p_show, p_season, p_episode in self.p_episodes: # Increment one step self.current.progress.group(Shows, 'matched:episodes').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_shows_unsupported, ids['show'], guid) continue key = (guid.service, guid.id) identifier = (season_num, episode_num) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) with elapsed.clock(Shows, 'run:plex_episodes:execute_handlers'): for data in self.get_data(SyncMedia.Episodes): with elapsed.clock(Shows, 'run:plex_episodes:t_objects'): t_show, t_season, t_episode = self.t_objects( self.trakt[(SyncMedia.Episodes, data)], pk, season_num, episode_num) # Execute episode handlers self.execute_handlers(SyncMedia.Episodes, data, key=ids['episode'], identifier=identifier, guid=guid, p_show=p_show, p_item=p_episode, t_show=t_show, t_item=t_episode) # Remove episode from `pending_episodes` if pk in self.p_episodes_pending and identifier in self.p_episodes_pending[ pk]: self.p_episodes_pending[pk].remove(identifier) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'matched:episodes').stop()
def run(self): for mo_id, guid, p_movie in self.p_movies: # Parse guid match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_unsupported, mo_id, guid) continue if not match.found: log.info('Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, mo_id) continue key = (match.guid.service, match.guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_movie.get('library_section'), mo_id, [key, pk]) if pk is None: # No `pk` found continue # Execute data handlers for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers( self.mode, SyncMedia.Movies, data, key=mo_id, p_item=p_movie, t_item=t_movie ) # Increment one step self.step(self.p_pending, data, pk) # Task checkpoint self.checkpoint() # Log details log_unsupported(log, 'Found %d unsupported movie(s)', self.p_unsupported) log.debug('Pending: %r', self.p_pending)
def run_episodes(self): for ids, guid, (season_num, episode_num), p_show, p_season, p_episode in self.p_episodes: # Process `p_guid` (map + validate) match = GuidParser.parse(guid, (season_num, episode_num)) if not match.supported: mark_unsupported(self.p_shows_unsupported, ids['show'], guid) continue if not match.found: log.info('Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, ids['show']) continue # Process episode self.run_episode(ids, match, p_show, p_episode) # Task checkpoint self.checkpoint()
def process_matched_movies(self): """Trigger actions for movies that have been matched in plex""" # Iterate over movies for rating_key, guid, p_item in self.p_movies: # Increment one step self.current.progress.group(Movies, 'matched:movies').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_unsupported, rating_key, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers( SyncMedia.Movies, data, key=rating_key, guid=guid, p_item=p_item, t_item=t_movie ) # Remove movie from `pending` set if pk and pk in self.p_pending: self.p_pending.remove(pk) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Movies, 'matched:movies').stop() # Report unsupported movies (unsupported guid) log_unsupported(log, 'Found %d unsupported movie(s)\n%s', self.p_unsupported)
def process_matched_movies(self): """Trigger actions for movies that have been matched in plex""" # Iterate over movies for rating_key, guid, p_item in self.p_movies: # Increment one step self.current.progress.group(Movies, 'matched:movies').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_unsupported, rating_key, guid, p_item) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers( SyncMedia.Movies, data, key=rating_key, guid=guid, p_item=p_item, t_item=t_movie ) # Remove movie from `pending` set if pk and pk in self.p_pending: self.p_pending.remove(pk) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Movies, 'matched:movies').stop() # Report unsupported movies (unsupported guid) log_unsupported(log, 'Found %d unsupported movie(s)\n%s', self.p_unsupported)
def run_episodes(self): for ids, guid, ( season_num, episode_num), p_show, p_season, p_episode in self.p_episodes: # Process `p_guid` (map + validate) match = GuidParser.parse(guid, (season_num, episode_num)) if not match.supported: mark_unsupported(self.p_shows_unsupported, ids['show'], guid) continue if not match.found: log.info( 'Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, ids['show']) continue # Process episode self.run_episode(ids, match, p_show, p_episode) # Task checkpoint self.checkpoint()
def run_shows(self): for sh_id, guid, p_show in self.p_shows: # Parse guid match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_shows_unsupported, sh_id, guid) continue if not match.found: log.info( 'Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, sh_id) continue key = (match.guid.service, match.guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) # Store in item map self.current.map.add(p_show.get('library_section'), sh_id, [key, pk]) if pk is None: # No `pk` found continue # Execute handlers for data in self.get_data(SyncMedia.Shows): t_show = self.trakt[(SyncMedia.Shows, data)].get(pk) # Execute show handlers self.execute_handlers(self.mode, SyncMedia.Shows, data, key=sh_id, p_item=p_show, t_item=t_show)
def process_matched_shows(self): # Iterate over plex shows for sh_id, guid, p_show in self.p_shows: # Increment one step self.current.progress.group(Shows, 'matched:shows').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_shows_unsupported, sh_id, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) for data in self.get_data(SyncMedia.Shows): t_show = self.trakt[(SyncMedia.Shows, data)].get(pk) # Execute show handlers self.execute_handlers( SyncMedia.Shows, data, key=sh_id, guid=guid, p_item=p_show, t_item=t_show ) # Remove show from `pending_shows` if pk and pk in self.p_shows_pending: self.p_shows_pending.remove(pk) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'matched:shows').stop()
def run_shows(self): for sh_id, guid, p_show in self.p_shows: # Parse guid match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_shows_unsupported, sh_id, guid) continue if not match.found: log.info('Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, sh_id) continue key = (match.guid.service, match.guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) # Store in item map self.current.map.add(p_show.get('library_section'), sh_id, [key, pk]) if pk is None: # No `pk` found continue # Execute handlers for data in self.get_data(SyncMedia.Shows): t_show = self.trakt[(SyncMedia.Shows, data)].get(pk) # Execute show handlers self.execute_handlers( self.mode, SyncMedia.Shows, data, key=sh_id, p_item=p_show, t_item=t_show )
def process_matched_shows(self): # Iterate over plex shows for sh_id, guid, p_show in self.p_shows: # Increment one step self.current.progress.group(Shows, 'matched:shows').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_shows_unsupported, sh_id, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) for data in self.get_data(SyncMedia.Shows): t_show = self.trakt[(SyncMedia.Shows, data)].get(pk) # Execute show handlers self.execute_handlers(SyncMedia.Shows, data, key=sh_id, guid=guid, p_item=p_show, t_item=t_show) # Remove show from `pending_shows` if pk and pk in self.p_shows_pending: self.p_shows_pending.remove(pk) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'matched:shows').stop()
def run(self): # Retrieve show sections p_sections, p_sections_map = self.sections('show') # Fetch episodes with account settings p_shows, p_seasons, p_episodes = self.plex.library.episodes.mapped( p_sections, ([ MetadataItem.library_section ], [], []), account=self.current.account.plex.key, parse_guid=True ) # TODO process seasons # Calculate total number of episodes pending = {} for data in self.get_data(SyncMedia.Episodes): t_episodes = [ (key, se, ep) for key, t_show in self.trakt[(SyncMedia.Episodes, data)].items() for se, t_season in t_show.seasons.items() for ep in t_season.episodes.iterkeys() ] if data not in pending: pending[data] = {} for key in t_episodes: pending[data][key] = False # Task started unsupported_shows = {} # Process shows for sh_id, guid, p_show in p_shows: if not guid or guid.service not in GUID_SERVICES: mark_unsupported(unsupported_shows, sh_id, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) # Store in item map self.current.map.add(p_show.get('library_section'), sh_id, [key, pk]) if pk is None: # No `pk` found continue # Execute data handlers for data in self.get_data(SyncMedia.Shows): t_show = self.trakt[(SyncMedia.Shows, data)].get(pk) # Execute show handlers self.execute_handlers( SyncMedia.Shows, data, key=sh_id, p_item=p_show, t_item=t_show ) # Process episodes for ids, guid, (season_num, episode_num), p_show, p_season, p_episode in p_episodes: if not guid or guid.service not in GUID_SERVICES: mark_unsupported(unsupported_shows, ids['show'], guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) if pk is None: # No `pk` found continue if not ids.get('episode'): # Missing `episode` rating key continue for data in self.get_data(SyncMedia.Episodes): t_show = self.trakt[(SyncMedia.Episodes, data)].get(pk) if t_show is None: # Unable to find matching show in trakt data continue t_season = t_show.seasons.get(season_num) if t_season is None: # Unable to find matching season in `t_show` continue t_episode = t_season.episodes.get(episode_num) if t_episode is None: # Unable to find matching episode in `t_season` continue self.execute_handlers( SyncMedia.Episodes, data, key=ids['episode'], p_item=p_episode, t_item=t_episode ) # Increment one step self.step(pending, data, (pk, season_num, episode_num)) # Task checkpoint self.checkpoint() # Log details log_unsupported(log, 'Found %d unsupported show(s)\n%s', unsupported_shows) log.debug('Pending: %r', pending)
def run(self): # TODO process seasons with elapsed.clock(Shows, 'run:shows'): # Process shows for sh_id, guid, p_show in self.p_shows: # Increment one step self.current.progress.group(Shows, 'shows').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_shows_unsupported, sh_id, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) # Store in item map self.current.map.add(p_show.get('library_section'), sh_id, [key, pk]) if pk is None: # No `pk` found continue # Iterate over changed data for key, result in self.trakt.changes: media, data = key[0:2] if media != SyncMedia.Shows: # Ignore changes that aren't for episodes continue if data == SyncData.Watchlist: # Ignore watchlist data continue if not self.is_data_enabled(data): # Data type has been disabled continue data_name = Cache.Data.get(data) if data_name not in result.changes: # No changes for collection continue for action, shows in result.changes[data_name].items(): t_show = shows.get(pk) if t_show is None: # Unable to find matching show in trakt data continue # Execute show handlers self.execute_handlers( SyncMedia.Shows, data, action=action, key=sh_id, p_item=p_show, t_item=t_show ) # Stop progress group self.current.progress.group(Shows, 'shows').stop() with elapsed.clock(Shows, 'run:episodes'): # Process episodes for ids, guid, (season_num, episode_num), p_show, p_season, p_episode in self.p_episodes: # Increment one step self.current.progress.group(Shows, 'episodes').step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_shows_unsupported, ids['show'], guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('shows').get(key) if pk is None: # No `pk` found continue if not ids.get('episode'): # Missing `episode` rating key continue for key, result in self.trakt.changes: media, data = key[0:2] if media != SyncMedia.Episodes: # Ignore changes that aren't for episodes continue if not self.is_data_enabled(data): # Data type has been disabled continue data_name = Cache.Data.get(data) if data_name not in result.changes: # No changes for collection continue for action, shows in result.changes[data_name].items(): t_show = shows.get(pk) if t_show is None: # Unable to find matching show in trakt data continue t_season = t_show.get('seasons', {}).get(season_num) if t_season is None: # Unable to find matching season in `t_show` continue t_episode = t_season.get('episodes', {}).get(episode_num) if t_episode is None: # Unable to find matching episode in `t_season` continue self.execute_handlers( SyncMedia.Episodes, data, action=action, key=ids['episode'], p_item=p_episode, t_item=t_episode ) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Shows, 'episodes').stop() # Log details log_unsupported(log, 'Found %d unsupported show(s)\n%s', self.p_shows_unsupported)
def run(self): # Retrieve movie sections p_sections, p_sections_map = self.sections('movie') # Fetch movies with account settings p_items = self.plex.library.movies.mapped( p_sections, [ MetadataItem.library_section ], account=self.current.account.plex.key, parse_guid=True ) # Calculate total number of movies pending = {} for data in self.get_data(SyncMedia.Movies): if data not in pending: pending[data] = {} for pk in self.trakt[(SyncMedia.Movies, data)]: pending[data][pk] = False # Task started unsupported_movies = {} for rating_key, guid, p_item in p_items: if not guid or guid.service not in GUID_SERVICES: mark_unsupported(unsupported_movies, rating_key, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_item.get('library_section'), rating_key, [key, pk]) if pk is None: # No `pk` found continue # Execute data handlers for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers( SyncMedia.Movies, data, key=rating_key, p_item=p_item, t_item=t_movie ) # Increment one step self.step(pending, data, pk) # Task checkpoint self.checkpoint() # Log details log_unsupported(log, 'Found %d unsupported movie(s)\n%s', unsupported_movies) log.debug('Pending: %r', pending)
def run(self): # Process movies for mo_id, guid, p_movie in self.p_movies: # Increment one step self.current.progress.group(Movies).step() # Parse guid match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_unsupported, mo_id, guid) continue if not match.found: log.info( 'Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, mo_id) continue key = (match.guid.service, match.guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_movie.get('library_section'), mo_id, [key, pk]) if pk is None: # No `pk` found continue # Run pull handlers if the item has been added recently if self.should_pull(mo_id, p_movie.get('added_at')): log.info( 'Movie %r has been added recently, running pull sync instead', mo_id) # Execute handlers for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers(SyncMode.Pull, SyncMedia.Movies, data, key=mo_id, p_item=p_movie, t_item=t_movie) else: # Execute handlers for changed data for data, action, t_movie in self.iter_changes( SyncMedia.Movies, pk): self.execute_handlers(self.mode, SyncMedia.Movies, data, action=action, key=mo_id, p_item=p_movie, t_item=t_movie) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Movies).stop() # Log details log_unsupported(log, 'Found %d unsupported movie(s)', self.p_unsupported)
def run(self): # Retrieve movie sections p_sections, p_sections_map = self.sections('movie') # Fetch movies with account settings p_items = self.plex.library.movies.mapped( p_sections, [MetadataItem.library_section], account=self.current.account.plex.key, parse_guid=True) # Calculate total number of movies pending = {} for data in self.get_data(SyncMedia.Movies): if data not in pending: pending[data] = {} for pk in self.trakt[(SyncMedia.Movies, data)]: pending[data][pk] = False # Task started unsupported_movies = {} for rating_key, guid, p_item in p_items: if not guid or guid.service not in GUID_SERVICES: mark_unsupported(unsupported_movies, rating_key, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_item.get('library_section'), rating_key, [key, pk]) if pk is None: # No `pk` found continue # Execute data handlers for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers(SyncMedia.Movies, data, key=rating_key, p_item=p_item, t_item=t_movie) # Increment one step self.step(pending, data, pk) # Task checkpoint self.checkpoint() # Log details log_unsupported(log, 'Found %d unsupported movie(s)\n%s', unsupported_movies) log.debug('Pending: %r', pending)
def run(self): # Process movies for mo_id, guid, p_movie in self.p_movies: # Increment one step self.current.progress.group(Movies).step() # Parse guid match = GuidParser.parse(guid) if not match.supported: mark_unsupported(self.p_unsupported, mo_id, guid) continue if not match.found: log.info('Unable to find identifier for: %s/%s (rating_key: %r)', guid.service, guid.id, mo_id) continue key = (match.guid.service, match.guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_movie.get('library_section'), mo_id, [key, pk]) if pk is None: # No `pk` found continue # Run pull handlers if the item has been added recently if self.should_pull(mo_id, p_movie.get('added_at')): log.info('Movie %r has been added recently, running pull sync instead', mo_id) # Execute handlers for data in self.get_data(SyncMedia.Movies): t_movie = self.trakt[(SyncMedia.Movies, data)].get(pk) self.execute_handlers( SyncMode.Pull, SyncMedia.Movies, data, key=mo_id, p_item=p_movie, t_item=t_movie ) else: # Execute handlers for changed data for data, action, t_movie in self.iter_changes(SyncMedia.Movies, pk): self.execute_handlers( self.mode, SyncMedia.Movies, data, action=action, key=mo_id, p_item=p_movie, t_item=t_movie ) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Movies).stop() # Log details log_unsupported(log, 'Found %d unsupported movie(s)', self.p_unsupported)
def run(self): # Process movies for mo_id, guid, p_item in self.p_movies: # Increment one step self.current.progress.group(Movies).step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_unsupported, mo_id, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_item.get('library_section'), mo_id, [key, pk]) if pk is None: # No `pk` found continue # Iterate over changed data for key, result in self.trakt.changes: media, data = key[0:2] if media != SyncMedia.Movies: # Ignore changes that aren't for movies continue if data == SyncData.Watchlist: # Ignore watchlist data continue if not self.is_data_enabled(data): # Data type has been disabled continue data_name = Cache.Data.get(data) if data_name not in result.changes: # No changes for collection continue for action, items in result.changes[data_name].items(): t_item = items.get(pk) if t_item is None: # No item found in changes continue self.execute_handlers( SyncMedia.Movies, data, action=action, key=mo_id, p_item=p_item, t_item=t_item ) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Movies).stop() # Log details log_unsupported(log, 'Found %d unsupported movie(s)\n%s', self.p_unsupported)
def run(self): # Process movies for mo_id, guid, p_item in self.p_movies: # Increment one step self.current.progress.group(Movies).step() # Ensure `guid` is available if not guid or guid.service not in GUID_SERVICES: mark_unsupported(self.p_unsupported, mo_id, guid) continue key = (guid.service, guid.id) # Try retrieve `pk` for `key` pk = self.trakt.table('movies').get(key) # Store in item map self.current.map.add(p_item.get('library_section'), mo_id, [key, pk]) if pk is None: # No `pk` found continue # Iterate over changed data for key, result in self.trakt.changes: media, data = key[0:2] if media != SyncMedia.Movies: # Ignore changes that aren't for movies continue if data == SyncData.Watchlist: # Ignore watchlist data continue if not self.is_data_enabled(data): # Data type has been disabled continue data_name = Cache.Data.get(data) if data_name not in result.changes: # No changes for collection continue for action, items in result.changes[data_name].items(): t_item = items.get(pk) if t_item is None: # No item found in changes continue self.execute_handlers(SyncMedia.Movies, data, action=action, key=mo_id, p_item=p_item, t_item=t_item) # Task checkpoint self.checkpoint() # Stop progress group self.current.progress.group(Movies).stop() # Log details log_unsupported(log, 'Found %d unsupported movie(s)\n%s', self.p_unsupported)