def download_manager(ret):
print_info(
'Download status value: Not Downloaded: 0 / Downloading: 1 / Downloaded: 2\n',
indicator=False)
if ret.action.download == DOWNLOAD_ACTION_LIST:
status = ret.action.download.list.status
status = int(status) if status is not None else None
delegate = get_download_class(instance=False)
delegate.download_status(status=status)
elif ret.action.download == DOWNLOAD_ACTION_MARK:
download_id = ret.action.download.mark.id
status = ret.action.download.mark.status
if not download_id or not status:
print_error('No id or status specified.')
download_obj = Download(_id=download_id)
download_obj.select_obj()
if not download_obj:
print_error('Download object does not exist.')
print_info('Download Object <{0} - {1}>, Status: {2}'.format(
download_obj.name, download_obj.episode, download_obj.status))
download_obj.status = status
download_obj.save()
print_success('Download status has been marked as {0}'.format(
DOWNLOAD_CHOICE_LIST_DICT.get(int(status))))
def add(ret):
# action add
# add bangumi by a list of bangumi name
if not Bangumi.get_all_bangumi():
print_warning('No bangumi data in database, fetching...')
update(ret)
for bangumi in ret.action.add.name:
bangumi_obj = Bangumi(name=bangumi)
data = bangumi_obj.select(one=True, fields=['id', 'name', 'keyword'])
if data:
followed_obj = Followed(bangumi_name=data['name'],
status=STATUS_FOLLOWED)
followed_obj.select_obj()
if not followed_obj or followed_obj.status == STATUS_NORMAL:
if not followed_obj:
ret, _ = get_maximum_episode(bangumi_obj, subtitle=False)
followed_obj.episode = ret['episode']
followed_obj.save()
else:
followed_obj.status = STATUS_FOLLOWED
followed_obj.save()
print_success('{0} has followed'.format(bangumi_obj))
else:
print_warning('{0} already followed'.format(bangumi_obj))
else:
print_error('{0} not found, please check the name'.format(bangumi))
def download_status(status=None):
print_info('Print download status in database')
DownloadService.download_status(status=status)
print()
print_info('Print download status in aria2c-rpc')
server = PatchedServerProxy(ARIA2_RPC_URL)
# self.server.aria2
status_dict = {
STATUS_DOWNLOADING: ['tellActive'],
STATUS_NOT_DOWNLOAD: ['tellWaiting'],
STATUS_DOWNLOADED: ['tellStopped'],
None: ['tellStopped', 'tellWaiting', 'tellActive'],
}
for method in status_dict.get(status):
if method not in ('tellActive', ):
params = (0, 1000)
else:
params = ()
data = server.aria2[method](*params)
if data:
print_warning('RPC {0}:'.format(method), indicator=False)
for row in data:
print_success('- {0}'.format(row['dir']), indicator=False)
for file in row['files']:
print_info(' * {0}'.format(file['path']),
indicator=False)
def update(ret):
print_info('marking bangumi status ...')
now = int(time.time())
for i in Followed.get_all_followed():
if i['updated_time'] and int(i['updated_time'] + 86400) < now:
followed_obj = Followed(bangumi_name=i['bangumi_name'])
followed_obj.status = STATUS_FOLLOWED
followed_obj.save()
print_info('updating bangumi data ...')
fetch(save=True, group_by_weekday=False)
print_info('updating subscriptions ...')
download_queue = []
if ret.action.update.name is None:
updated_bangumi_obj = Followed.get_all_followed()
else:
updated_bangumi_obj = []
for i in ret.action.update.name:
f = Followed(bangumi_name=i)
f.select_obj()
updated_bangumi_obj.append(f)
for subscribe in updated_bangumi_obj:
print_info('fetching %s ...' % subscribe['bangumi_name'])
bangumi_obj = Bangumi(name=subscribe['bangumi_name'])
bangumi_obj.select_obj()
# filter by subtitle group
if not bangumi_obj:
print_error(
'The bangumi {0} you subscribed does not exists ..'.format(
subscribe['bangumi_name']),
exit_=False)
continue
episode, all_episode_data = get_maximum_episode(bangumi=bangumi_obj)
if episode.get('episode') > subscribe['episode']:
episode_range = range(subscribe['episode'] + 1,
episode.get('episode'))
print_success('%s updated, episode: %d' %
(subscribe['bangumi_name'], episode['episode']))
_ = Followed(bangumi_name=subscribe['bangumi_name'])
_.episode = episode['episode']
_.status = STATUS_UPDATED
_.updated_time = int(time.time())
_.save()
download_queue.append(episode)
for i in episode_range:
for epi in all_episode_data:
if epi['episode'] == i:
download_queue.append(epi)
break
if ret.action.update and ret.action.update.download:
download_prepare(download_queue)
print_info('Re-downloading ...')
download_prepare(
Download.get_all_downloads(status=STATUS_NOT_DOWNLOAD))
def search_(ret):
if not ret.count:
ret.count = 3
data = search(ret.keyword, count=ret.count, filter_=ret.regex_filter)
for i in data:
print_success(i['title'])
if ret.download:
download_prepare(data)
def mark(ret):
name = ret.name
episode = ret.episode
followed_obj = Followed(bangumi_name=name)
followed_obj.select_obj()
if not followed_obj:
print_error('Subscribe <%s> does not exist.' % name)
if episode is not None:
followed_obj.episode = episode
followed_obj.save()
print_success('%s has been mark as episode: %s' %
(followed_obj, followed_obj.episode))
else:
print_info('%s, episode: %s' % (followed_obj, followed_obj.episode))
def create_dir():
if not os.environ.get('HOME', ''):
print_warning('$HOME not set, use \'/tmp/\'')
tools_path = os.path.join(BGMI_PATH, 'tools')
# bgmi home dir
path_to_create = (BGMI_PATH, BGMI_SAVE_PATH, BGMI_TMP_PATH, tools_path)
try:
for path in path_to_create:
if not os.path.exists(path):
print_success('%s created successfully' % path)
os.mkdir(path)
else:
print_warning('%s already exists' % path)
except OSError as e:
print_error('Error: {0}'.format(str(e)))
def delete(ret):
# action delete
# just delete subscribed bangumi or clear all the subscribed bangumi
if ret.action.delete.clear_all:
if Followed.delete_followed(batch=ret.action.delete.batch):
print_success('all subscriptions have been deleted')
else:
print_error('user canceled')
elif ret.action.delete.name:
for name in ret.action.delete.name:
followed = Followed(bangumi_name=name)
if followed.select():
followed.delete()
print_warning('Bangumi %s has been deleted' % name)
else:
print_error('Bangumi %s does not exist' % name, exit_=False)
else:
print_warning('Nothing has been done.')
def followed(ret):
if ret.action.followed == FOLLOWED_ACTION_MARK:
name = ret.action.followed.mark.name
episode = ret.action.followed.mark.episode
followed_obj = Followed(bangumi_name=name)
followed_obj.select_obj()
if not followed_obj:
print_error('Subscribe <%s> does not exist.' % name)
if episode:
followed_obj.episode = episode
followed_obj.save()
print_success('%s has been mark as episode: %s' %
(followed_obj, followed_obj.episode))
else:
print_info('%s, episode: %s' %
(followed_obj, followed_obj.episode))
else:
bangumi_calendar(force_update=False, followed=True, save=False)
def download_manager(ret):
if ret.id:
download_id = ret.id
status = ret.status
if download_id is None or status is None:
print_error('No id or status specified.')
download_obj = Download(_id=download_id)
download_obj.select_obj()
if not download_obj:
print_error('Download object does not exist.')
print_info('Download Object <{0} - {1}>, Status: {2}'.format(
download_obj.name, download_obj.episode, download_obj.status))
download_obj.status = status
download_obj.save()
print_success('Download status has been marked as {0}'.format(
DOWNLOAD_CHOICE_LIST_DICT.get(int(status))))
else:
status = ret.status
status = int(status) if status is not None else None
delegate = get_download_class(instance=False)
delegate.download_status(status=status)
def fetch_(ret):
bangumi_obj = Bangumi(name=ret.name)
bangumi_obj.select_obj()
followed_obj = Followed(bangumi_name=bangumi_obj.name)
followed_obj.select_obj()
followed_filter_obj = Filter(bangumi_name=ret.name)
followed_filter_obj.select_obj()
print_filter(followed_filter_obj)
if bangumi_obj:
print_info('Fetch bangumi {0} ...'.format(bangumi_obj.name))
_, data = get_maximum_episode(
bangumi_obj, ignore_old_row=False if ret.not_ignore else True)
if not data:
print_warning('Nothing.')
for i in data:
print_success(i['title'])
else:
print_error('Bangumi {0} not exist'.format(ret.name))
def download_status(status=None):
last_status = -1
for download_data in Download.get_all_downloads(status=status):
latest_status = download_data['status']
name = ' {0}. <{1}: {2}>'.format(download_data['id'],
download_data['name'],
download_data['episode'])
if latest_status != last_status:
if latest_status == STATUS_DOWNLOADING:
print('Downloading items:')
elif latest_status == STATUS_NOT_DOWNLOAD:
print('Not downloaded items:')
elif latest_status == STATUS_DOWNLOADED:
print('Downloaded items:')
if download_data['status'] == STATUS_NOT_DOWNLOAD:
print_info(name, indicator=False)
elif download_data['status'] == STATUS_DOWNLOADING:
print_warning(name, indicator=False)
elif download_data['status'] == STATUS_DOWNLOADED:
print_success(name, indicator=False)
last_status = download_data['status']
def install():
# install xunlei-lixian
import tarfile
import requests
print_info(
'Downloading xunlei-lixian from https://github.com/iambus/xunlei-lixian/'
)
r = requests.get(
'https://github.com/iambus/xunlei-lixian/tarball/master',
stream=True,
headers={'Accept-Encoding': ''})
f = NamedTemporaryFile(delete=False)
with f:
for chunk in r.iter_content(chunk_size=1024):
if chunk:
f.write(chunk)
f.close()
print_success('Download successfully, save at %s, extracting ...' %
f.name)
zip_file = tarfile.open(f.name, 'r:gz')
zip_file.extractall(os.path.join(BGMI_PATH, 'tools/xunlei-lixian'))
dir_name = zip_file.getnames()[0]
print_info('Create link file ...')
if not os.path.exists(BGMI_LX_PATH):
os.symlink(
os.path.join(
BGMI_PATH,
'tools/xunlei-lixian/{0}/lixian_cli.py'.format(dir_name)),
BGMI_LX_PATH)
else:
print_warning('{0} already exists'.format(BGMI_LX_PATH))
print_success('All done')
print_info(
'Please run command \'{0} config\' to configure your lixian-xunlei '
'(Notice: only for Thunder VIP)'.format(BGMI_LX_PATH))
def download_status(status=None):
Aria2DownloadRPC.check_aria2c_version()
print_info('Print download status in database')
DownloadService.download_status(status=status)
print()
print_info('Print download status in aria2c-rpc')
try:
server = PatchedServerProxy(ARIA2_RPC_URL)
# self.server.aria2
status_dict = {
STATUS_DOWNLOADING: ['tellActive'],
STATUS_NOT_DOWNLOAD: ['tellWaiting'],
STATUS_DOWNLOADED: ['tellStopped'],
None: ['tellStopped', 'tellWaiting', 'tellActive'],
}
for method in status_dict.get(status):
if method not in ('tellActive', ):
params = (0, 1000)
else:
params = ()
if Aria2DownloadRPC.old_version:
data = server.aria2[method](*params)
else:
data = server.aria2[method](ARIA2_RPC_TOKEN, *params)
if data:
print_warning('RPC {0}:'.format(method), indicator=False)
for row in data:
print_success('- {0}'.format(row['dir']), indicator=False)
for file_ in row['files']:
print_info(' * {0}'.format(file_['path']),
indicator=False)
except Exception as e:
print_error('Cannot connect to aria2-rpc server')
def main():
c = CommandParser()
action = c.add_arg_group('action')
sub_parser_add = action.add_sub_parser(ACTION_ADD,
help='Subscribe bangumi.')
sub_parser_add.add_argument('name',
arg_type='+',
required=True,
help='Bangumi name to subscribe.')
sub_parser_filter = action.add_sub_parser(ACTION_FILTER,
help='Set bangumi fetch filter.')
sub_parser_filter.add_argument('name',
required=True,
help='Bangumi name to set the filter.')
sub_parser_filter.add_argument('subtitle_group',
help='Subtitle group name.')
sub_parser_filter.add_argument('--remove',
help='Remove subtitle group filter.')
sub_parser_filter.add_argument(
'--remove-all',
help='Remove all the subtitle group filter.',
mutex='--remove')
sub_parser_del = action.add_sub_parser(ACTION_DELETE,
help='Unsubscribe bangumi.')
sub_parser_del.add_argument('--name',
arg_type='+',
mutex='--clear-all',
help='Bangumi name to unsubscribe.')
sub_parser_del.add_argument('--clear-all',
help='Clear all the subscriptions.')
sub_parser_del.add_argument('--batch', help='No confirmation.')
sub_parser_fetch = action.add_sub_parser(ACTION_FETCH,
help='Fetch a specific bangumi.')
sub_parser_fetch.add_argument('name',
help='Bangumi name to fetch.',
required=True)
sub_parser_update = action.add_sub_parser(
ACTION_UPDATE,
help='Update bangumi calendar and '
'subscribed bangumi episode.')
sub_parser_update.add_argument('--download',
help='Download the bangumi when updated.')
sub_parser_cal = action.add_sub_parser(ACTION_CAL,
help='Print bangumi calendar.')
sub_parser_cal.add_argument('filter',
default='today',
choice=FILTER_CHOICES,
help='Calendar form filter %s.' %
', '.join(FILTER_CHOICES))
sub_parser_cal.add_argument('--today',
help='Show bangumi calendar for today.')
sub_parser_cal.add_argument(
'--force-update', help='Get the newest bangumi calendar from dmhy.')
sub_parser_cal.add_argument(
'--no-save', help='Do not save the bangumi data when force update.')
sub_parser_config = action.add_sub_parser(ACTION_CONFIG,
help='Config BGmi.')
sub_parser_config.add_argument('name', help='Config name')
sub_parser_config.add_argument('value', help='Config value')
sub_parser_followed = action.add_sub_parser(
ACTION_FOLLOWED, help='Followed bangumi manager.')
sub_parser_followed.add_sub_parser('list', help='List followed bangumi.')
followed_mark = sub_parser_followed.add_sub_parser(
'mark', help='Mark specific bangumi\'s episode.')
followed_mark.add_argument('name', help='Bangumi name.', required=True)
followed_mark.add_argument('episode', help='Bangumi episode.')
sub_parser_download = action.add_sub_parser(ACTION_DOWNLOAD,
help='Download manager.')
download_list = sub_parser_download.add_sub_parser(
'list', help='List download queue.')
download_list.add_argument('status',
help='Download status: 0, 1, 2',
choice=(0, 1, 2, None))
download_mark = sub_parser_download.add_sub_parser(
'mark', help='Mark download status with a specific id.')
download_mark.add_argument('id', help='Download id')
download_mark.add_argument('status',
help='Status will be marked',
choice=(0, 1, 2))
positional = c.add_arg_group('positional')
positional.add_argument('install', help='Install xunlei-lixian for BGmi.')
c.add_argument('-h', help='Print help text.')
c.add_argument('--version', help='Show the version of BGmi.')
c.add_argument('--debug', help='Enable DEBUG mode.')
ret = c.parse_command()
if ret.version:
print_version()
raise SystemExit
if ret.positional.install == 'install':
import bgmi.setup
bgmi.setup.install()
raise SystemExit
elif ret.action == ACTION_ADD:
add(ret)
elif ret.action == ACTION_FILTER:
filter_(ret)
elif ret.action == ACTION_FETCH:
bangumi_obj = Bangumi(name=ret.action.fetch.name)
bangumi_obj.select_obj()
followed_obj = Followed(bangumi_name=bangumi_obj.name)
followed_obj.select_obj()
if bangumi_obj:
print_info('Fetch bangumi {0} ...'.format(bangumi_obj.name))
_, data = get_maximum_episode(bangumi_obj)
for i in data:
print_success(i['title'])
else:
print_error('Bangumi {0} not exist'.format(ret.action.fetch.name))
elif ret.action == ACTION_DELETE:
delete(ret)
elif ret.action == ACTION_UPDATE:
update(ret)
elif ret.action == ACTION_CAL:
cal(ret)
elif ret.action == ACTION_CONFIG:
write_config(ret.action.config.name, ret.action.config.value)
elif ret.action == ACTION_FOLLOWED:
if not ret.action.followed == 'mark' and not ret.action.followed.list:
c.print_help()
else:
followed(ret)
elif ret.action == ACTION_DOWNLOAD:
if ret.action.download in DOWNLOAD_ACTION:
download_manager(ret)
else:
c.print_help()
else:
c.print_help()
def update(ret):
ignore = False if ret.not_ignore else True
print_info('marking bangumi status ...')
now = int(time.time())
for i in Followed.get_all_followed():
if i['updated_time'] and int(i['updated_time'] + 86400) < now:
followed_obj = Followed(bangumi_name=i['bangumi_name'])
followed_obj.status = STATUS_FOLLOWED
followed_obj.save()
print_info('updating bangumi data ...')
fetch(save=True, group_by_weekday=False)
print_info('updating subscriptions ...')
download_queue = []
if ret.download:
if not ret.name:
print_warning('No specified bangumi, ignore `--download` option')
if len(ret.name) > 1:
print_warning(
'Multiple specified bangumi, ignore `--download` option')
if not ret.name:
updated_bangumi_obj = Followed.get_all_followed()
else:
updated_bangumi_obj = []
for i in ret.name:
f = Followed(bangumi_name=i)
f.select_obj()
updated_bangumi_obj.append(f)
for subscribe in updated_bangumi_obj:
print_info('fetching %s ...' % subscribe['bangumi_name'])
bangumi_obj = Bangumi(name=subscribe['bangumi_name'])
bangumi_obj.select_obj()
followed_obj = Followed(bangumi_name=subscribe['bangumi_name'])
followed_obj.select_obj()
# filter by subtitle group
if not bangumi_obj or not followed_obj:
print_error(
'Bangumi<{0}> does not exist or not been followed.'.format(
subscribe['bangumi_name']),
exit_=False)
continue
episode, all_episode_data = get_maximum_episode(bangumi=bangumi_obj,
ignore_old_row=ignore,
max_page=1)
if (episode.get('episode') > subscribe['episode']) or (len(
ret.name) == 1 and ret.download):
if len(ret.name) == 1 and ret.download:
episode_range = ret.download
else:
episode_range = range(subscribe['episode'] + 1,
episode.get('episode', 0) + 1)
print_success('%s updated, episode: %d' %
(subscribe['bangumi_name'], episode['episode']))
followed_obj.episode = episode['episode']
followed_obj.status = STATUS_UPDATED
followed_obj.updated_time = int(time.time())
followed_obj.save()
for i in episode_range:
for epi in all_episode_data:
if epi['episode'] == i:
download_queue.append(epi)
break
if ret.download is not None:
download_prepare(download_queue)
print_info('Re-downloading ...')
download_prepare(
Download.get_all_downloads(status=STATUS_NOT_DOWNLOAD))
