def __init__(self, token, fullURL, tvdata_on_plex=None, didend=None, toGet=None, verify=True, doLarge=False): super(HowdyTVGUI, self).__init__(None, isIsolated=True, doQuit=True) self.fullURL = fullURL self.token = token self.tvdb_token = get_token(verify=verify) self.verify = verify if not doLarge: fontSize = 13 else: fontSize = 26 self.setStyleSheet(""" QWidget { font-family: Consolas; font-size: %dpx; }""" % fontSize) self.hide() # showsToExclude = tv.get_shows_to_exclude(tvdata_on_plex) self.initThread = HowdyTVGUIThread(self, self.fullURL, self.token, self.tvdb_token, tvdata_on_plex=tvdata_on_plex, didend=didend, toGet=toGet, verify=verify, showsToExclude=showsToExclude) self.initThread.start()
def refreshTVShows(self): self.initThread.startDialog.emit('REFRESHING TV SHOWS') showsToExclude = tv.get_shows_to_exclude() self.initThread.reset(showsToExclude) self.initThread.start() # ## now send signals/run actions self.tm.setFilterString(self.filterOnTVShows.text()) self.tm.setFilterStatus(self.qbg.checkedId())
def show_excluded_shows(tvdata): return tv.get_shows_to_exclude(tvdata=tvdata)
def main(): time0 = time.time() parser = ArgumentParser() parser.add_argument('--noverify', dest='do_verify', action='store_false', default=True, help='If chosen, do not verify the SSL connection.') parser.add_argument('--local', dest='do_local', action='store_true', default=False, help='Check for locally running plex server.') parser.add_argument('--info', dest='do_info', action='store_true', default=False, help='If chosen, run with INFO logging mode.') args = parser.parse_args() logger = logging.getLogger() if args.do_info: logger.setLevel(logging.INFO) # ## function to do the processing step = 0 print('%d, started on %s' % (step, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p'))) # ## get plex server token dat = core.checkServerCredentials(doLocal=args.do_local, verify=args.do_verify) if dat is None: step += 1 print('\n'.join([ '%d, error, could not access local Plex server in %0.3f seconds. Exiting...' % (step, time.time() - time0), '%d, finished on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ])) return fullURL, token = dat # ## first find out which libraries are the TV show ones library_dict = core.get_libraries(token, fullURL=fullURL, do_full=True) if library_dict is None: step += 1 print('\n'.join([ '%d, error, could not access libraries in plex server in %0.3f seconds. Exiting...' % (step, time.time() - time0), '%d, finished on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ])) return # valid_keys = list( filter(lambda key: library_dict[key][-1] == 'show', library_dict)) if len(valid_keys) == 0: step += 1 print('\n'.join([ '%d, Error, could not find a TV show library in %0.3f seconds. Exiting...' % (time.time() - time0, step), '%d, finished on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ])) return tvlib_title = library_dict[max(valid_keys)][0] step += 1 nowdate = datetime.datetime.now().date() print('%d, found TV library: %s.' % (step, tvlib_title)) # ## now get the future TV shows tvdata = core.get_library_data(tvlib_title, token=token, fullURL=fullURL) showsToExclude = tv.get_shows_to_exclude(tvdata) if len(showsToExclude) != 0: step += 1 print('%d, excluding these TV shows: %s.' % (step, '; '.join(showsToExclude))) future_shows_dict = tv.get_future_info_shows(tvdata, verify=args.do_verify, showsToExclude=showsToExclude, fromDate=nowdate) for show in future_shows_dict: tdelta = future_shows_dict[show]['start_date'] - nowdate future_shows_dict[show]['days_to_new_season'] = tdelta.days if len(future_shows_dict) == 0: step += 1 print('%d, found no TV shows with new seasons.' % step) print('%d, finished on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p'))) return step += 1 print( '%d, Found %d TV shows with new seasons after %s, in %0.3f seconds.' % (step, len(future_shows_dict), nowdate.strftime('%B %d, %Y'), time.time() - time0)) print('\n') all_new_show_data = list( map( lambda show: (show, future_shows_dict[show]['max_last_season'], future_shows_dict[show]['min_next_season'], future_shows_dict[ show]['start_date'].strftime('%B %d, %Y'), future_shows_dict[ show]['days_to_new_season']), sorted(future_shows_dict, key=lambda shw: (future_shows_dict[shw]['start_date'], shw)))) print('%s\n' % tabulate.tabulate(all_new_show_data, headers=[ 'SHOW', 'LAST SEASON', 'NEXT SEASON', 'AIR DATE', 'DAYS TO NEW SEASON' ])) step += 1 print('\n'.join([ '%d, processed everything in %0.3f seconds.' % (step, time.time() - time0), '%d, finished everything on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ]))
def main(): time0 = time.time() default_time = 1000 default_iters = 2 default_num_threads = 2 * multiprocessing.cpu_count() # parser = ArgumentParser() parser.add_argument( '--maxtime', dest='maxtime_in_secs', type=int, action='store', default=default_time, help=' '.join([ 'The maximum amount of time to spend (in seconds),', 'per candidate magnet link,', 'trying to download a TV show.', 'Default is %d seconds.' % default_time ])) parser.add_argument( '--num', dest='num_iters', type=int, action='store', default=default_iters, help=' '.join([ 'The maximum number of different magnet links to try', 'before giving up. Default is %d.' % default_iters ])) parser.add_argument( '--token', dest='token', type=str, action='store', help='Optional argument. If chosen, user provided Plex access token.') parser.add_argument( '--debuglevel', dest='debug_level', action='store', type=str, default='None', choices=['None', 'info', 'debug'], help= 'Choose the debug level for the system logger. Default is None (no logging). Can be one of None (no logging), info, or debug.' ) parser.add_argument( '--numthreads', dest='numthreads', type=int, action='store', default=default_num_threads, help= 'Number of threads over which to search for TV shows in my library. Default is %d.' % default_num_threads) parser.add_argument( '--nomax', dest='do_restrict_maxsize', action='store_false', default=True, help='If chosen, do not restrict maximum size of downloaded file.') parser.add_argument( '--nomin', dest='do_restrict_minsize', action='store_false', default=True, help='If chosen, do not restrict minimum size of downloaded file.') parser.add_argument( '--raw', dest='do_raw', action='store_true', default=False, help='If chosen, then use the raw string to specify TV show torrents.') args = parser.parse_args() # logger = logging.getLogger() if args.debug_level == 'info': logger.setLevel(logging.INFO) if args.debug_level == 'debug': logger.setLevel(logging.DEBUG) assert (args.maxtime_in_secs >= 60), 'error, max time must be >= 60 seconds.' assert (args.num_iters >= 1), 'error, must have a positive number of maximum iterations.' step = 0 print('%d, started on %s' % (step, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p'))) step += 1 # ## get plex server token dat = core.checkServerCredentials(doLocal=True) if dat is None: print('\n'.join([ '%d, error, could not access local Plex server in %0.3f seconds. Exiting...' % (step, time.time() - time0), finish_statement(step) ])) return fullURL, token = dat if args.token is not None: token = args.token # ## first find out which libraries are the TV show ones library_dict = core.get_libraries(token, fullURL=fullURL, do_full=True) if library_dict is None: print('\n'.join([ '%d, error, could not access libraries in plex server in %0.3f seconds. Exiting...' % (step, time.time() - time0), finish_statement(step) ])) return # valid_keys = list( filter(lambda key: library_dict[key][-1] == 'show', library_dict)) if len(valid_keys) == 0: print('\n'.join([ '%d, Error, could not find a TV show library in %0.3f seconds. Exiting...' % (time.time() - time0, step), finish_statement(step) ])) return tvlib_title = library_dict[max(valid_keys)][0] print('%d, found TV library: %s.' % (step, tvlib_title)) step += 1 # ## now get the TV shows time0 = time.time() tvdata = core.get_library_data(tvlib_title, token=token, num_threads=args.numthreads) print('%d, found %d shows in the TV library, in %0.3f seconds.' % (step, len(tvdata), time.time() - time0)) step += 1 showsToExclude = tv.get_shows_to_exclude(tvdata) if len(showsToExclude) != 0: print('%d, excluding these TV shows: %s.' % (step, '; '.join(showsToExclude))) step += 1 tvdb_token = get_token() if tvdb_token is None: print('\n'.join([ '%d, error, could not access the TVDB API server in %0.3f seconds. Exiting...' % (step, time.time() - time0) ])) return toGet = tv.get_remaining_episodes(tvdata, showSpecials=False, showsToExclude=showsToExclude, num_threads=args.numthreads) if len(toGet) == 0: print('\n'.join([ '%d, no episodes to download in %0.3f seconds. Exiting...' % (step, time.time() - time0), finish_statement(step) ])) return print('%d, took %0.3f seconds to get list of %d episodes to download.' % (step, time.time() - time0, sum(map(lambda tvshow: len(toGet[tvshow]['episodes']), toGet)))) step += 1 # ## now download these episodes tvTorUnits, newdirs = tv.create_tvTorUnits( toGet, restrictMaxSize=args.do_restrict_maxsize, restrictMinSize=args.do_restrict_minsize, do_raw=args.do_raw) print('%d, here are the %d episodes to get: %s.' % (step, len(tvTorUnits), ', '.join( map(lambda tvTorUnit: tvTorUnit['torFname'], tvTorUnits)))) step += 1 tv.download_batched_tvtorrent_shows(tvTorUnits, newdirs=newdirs, maxtime_in_secs=args.maxtime_in_secs, num_iters=args.num_iters) print('\n'.join([ '%d, everything done in %0.3f seconds.' % (step, time.time() - time0), finish_statement(step) ]))
def main(): time0 = time.time() parser = ArgumentParser() parser.add_argument( '--years', dest='s_years', action='store', type=str, help='Give a list of years as a string, such as "1980,1981". Optional.' ) parser.add_argument('--local', dest='do_local', action='store_true', default=False, help='Check for locally running plex server.') parser.add_argument( '--dirname', dest='dirname', action='store', type=str, default=os.getcwd(), help='Directory into which to store those plots. Default is %s.' % os.getcwd()) parser.add_argument('--noverify', dest='do_verify', action='store_false', default=True, help='If chosen, do not verify SSL connections.') args = parser.parse_args() # ## function to do the processing step = 0 print('%d, started on %s' % (step, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p'))) if args.s_years is not None: try: years = sorted( set(map(lambda tok: int(tok), args.s_years.split(',')))) except: step += 1 print('%d, did not give a valid set of years.' % step) years = [] else: years = [] # ## get plex server token dat = core.checkServerCredentials(doLocal=args.do_local, verify=args.do_verify) if dat is None: step += 1 print('\n'.join([ '%d, error, could not access local Plex server in %0.3f seconds. Exiting...' % (step, time.time() - time0), '%d, finished on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ])) return fullURL, token = dat # ## first find out which libraries are the TV show ones library_dict = core.get_libraries(token, fullURL=fullURL, do_full=True) if library_dict is None: step += 1 print('\n'.join([ '%d, error, could not access libraries in plex server in %0.3f seconds. Exiting...' % (step, time.time() - time0), '%d, finished on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ])) return # valid_keys = list( filter(lambda key: library_dict[key][-1] == 'show', library_dict)) if len(valid_keys) == 0: step += 1 print('\n'.join([ '%d, Error, could not find a TV show library in %0.3f seconds. Exiting...' % (time.time() - time0, step), '%d, finished on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ])) return tvlib_title = library_dict[max(valid_keys)][0] step += 1 print('%d, found TV library: %s.' % (step, tvlib_title)) # ## now get the TV shows tvdata = core.get_library_data(tvlib_title, token=token, fullURL=fullURL, num_threads=16) showsToExclude = tv.get_shows_to_exclude(tvdata) if len(showsToExclude) != 0: step += 1 print('%d, excluding these TV shows: %s.' % (step, '; '.join(showsToExclude))) # ## now actual meat of the computation tvdata_date_dict = tv.get_tvdata_ordered_by_date(tvdata) min_year = min(tvdata_date_dict.keys()).year max_year = max(tvdata_date_dict.keys()).year possible_years_set = set(map(lambda date: date.year, tvdata_date_dict)) step += 1 if len(years) == 0: years = sorted(possible_years_set) print('%d, no years specified. We will use %s total: %s.' % (step, _print_years(len(years)), ', '.join( map(lambda year: '%d' % year, years)))) else: cand_years = sorted(set(years) & possible_years_set) if len(cand_years) == 0: print('\n'.join([ '%d, no intersection between the %s chosen (%s) and the %d years in the library.' % (step, _print_years(len(years)), ', '.join( lambda yr: '%d' % year, years), len(possible_years_set)), 'Instead, we will use %s total: %s.' % (_print_years(len(possible_years_set)), ', '.join( map(lambda year: '%d' % year, sorted(possible_years_set)))) ])) years = sorted(possible_years_set) else: print('%d, we found %s to use: %s.' % (step, _print_years(len(cand_years)), ', '.join( map(lambda year: '%d' % year, cand_years)))) years = cand_years step += 1 print('%d, started processing %s of TV shows after %0.3f seconds.' % (step, _print_years(len(years)), time.time() - time0)) manager = Manager() shared_step = manager.Value('step', step) num_procced = manager.Value('nump', 0) lock = manager.RLock() pool = Pool(processes=cpu_count()) def _process_year(year): tv.create_plot_year_tvdata(tvdata_date_dict, year, shouldPlot=True, dirname=args.dirname) lock.acquire() shared_step.value += 1 num_procced.value += 1 print( '%d, finished processing year = %d (%02d / %02d) in %0.3f seconds.' % (shared_step.value, year, num_procced.value, len(years), time.time() - time0)) lock.release() _ = list(pool.map(_process_year, years)) step = shared_step.value + 1 print('\n'.join([ '%d, processed all %s in %0.3f seconds.' % (step, _print_years(len(years)), time.time() - time0), '%d, finished everything on %s.' % (step + 1, datetime.datetime.now().strftime('%B %d, %Y @ %I:%M:%S %p')) ]))