def display_magnet_pack(self, magnet_url, info_hash): from modules.source_utils import supported_video_extensions try: end_results = [] append = end_results.append extensions = supported_video_extensions() result = self.instant_transfer(magnet_url) if not 'status' in result or result['status'] != 'success': return None for item in result.get('content'): if any( item.get('path').lower().endswith(x) for x in extensions) and not item.get('link', '') == '': try: path = item['path'].split('/')[-1] except: path = item['path'] append({ 'link': item['link'], 'filename': path, 'size': item['size'] }) return end_results except: return None
def rd_external_browser(magnet, filtering_list): try: episode_match = False torrent_id = None torrent_keys = [] append = torrent_keys.append extensions = supported_video_extensions() magnet_url = HTMLParser().unescape(magnet) r = re.search(r'''magnet:.+?urn:([a-zA-Z0-9]+):([a-zA-Z0-9]+)''', str(magnet), re.I) infoHash = r.group(2).lower() torrent_files = RealDebrid.check_hash(infoHash) torrent_files = torrent_files[infoHash]['rd'][0] try: files_tuple = sorted([ (k, v['filename'].lower()) for k, v in torrent_files.items() if v['filename'].lower().endswith(tuple(extensions)) ]) except: return None files_tuple.sort() for i in files_tuple: if any(x in i[1] for x in filtering_list): episode_match = True append(i[0]) if not episode_match: return None if not torrent_keys: return None torrent_keys = ','.join(torrent_keys) torrent = RealDebrid.add_magnet(magnet_url) torrent_id = torrent['id'] RealDebrid.add_torrent_select(torrent_id, torrent_keys) torrent_files = RealDebrid.user_cloud_info(torrent_id) file_info = [ i for i in torrent_files['files'] if i['path'].lower().endswith(tuple(extensions)) ] file_urls = torrent_files['links'] pack_info = [ dict(i.items() + [('url_link', file_urls[c])]) for c, i in enumerate(file_info) ] pack_info.sort(key=lambda k: k['path']) for item in pack_info: filename = clean_title(item['path']) if any(x in filename for x in filtering_list): correct_result = item break url_link = correct_result['url_link'] RealDebrid.delete_torrent(torrent_id) return resolve_rd({'url': url_link, 'play': 'false'}) except: if torrent_id: RealDebrid.delete_torrent(torrent_id) return None
def browse_ad_cloud(folder): def _builder(): for count, item in enumerate(links, 1): try: cm = [] url_link = item['link'] name = clean_file_name(item['filename']).upper() size = item['size'] display_size = float(int(size)) / 1073741824 display = '%02d | [B]%s[/B] | %.2f GB | [I]%s [/I]' % ( count, file_str, display_size, name) url_params = { 'mode': 'alldebrid.resolve_ad', 'url': url_link, 'play': 'true' } url = build_url(url_params) down_file_params = { 'mode': 'downloader', 'name': name, 'url': url_link, 'action': 'cloud.alldebrid', 'image': default_ad_icon } cm.append( (down_str, 'RunPlugin(%s)' % build_url(down_file_params))) listitem = make_listitem() listitem.setLabel(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_ad_icon, 'poster': default_ad_icon, 'thumb': default_ad_icon, 'fanart': fanart, 'banner': default_ad_icon }) listitem.setInfo('video', {}) yield (url, listitem, False) except: pass __handle__ = int(argv[1]) file_str, down_str = ls(32743).upper(), ls(32747) extensions = supported_video_extensions() links = json.loads(folder) links = [ i for i in links if i['filename'].lower().endswith(tuple(extensions)) ] kodi_utils.add_items(__handle__, list(_builder())) kodi_utils.set_content(__handle__, 'files') kodi_utils.end_directory(__handle__) kodi_utils.set_view_mode('view.premium')
def results(self, info): try: if not enabled_debrids_check('ad'): return internal_results(self.scrape_provider, self.sources) self.title_filter = filter_by_name(self.scrape_provider) self.sources, self.folder_results, self.scrape_results = [], [], [] self.db_type = info.get('db_type') self.title = info.get('title') self.year = info.get('year') if self.year: self.rootname = '%s (%s)' % (self.title, self.year) else: self.rootname = self.title self.season = info.get('season') self.episode = info.get('episode') if self.db_type == 'episode': self.seas_ep_query_list = seas_ep_query_list(self.season, self.episode) self.extensions = supported_video_extensions() self.folder_query = clean_title(normalize(self.title)) self._scrape_cloud() if not self.scrape_results: return internal_results(self.scrape_provider, self.sources) self.aliases = get_aliases_titles(info.get('aliases', [])) def _process(): for item in self.scrape_results: try: file_name = normalize(item['filename']) if self.title_filter and not 'assigned_folder' in item: if not check_title(self.title, file_name, self.aliases, self.year, self.season, self.episode): continue file_dl = item['link'] URLName = clean_file_name(file_name).replace('html', ' ').replace('+', ' ').replace('-', ' ') size = round(float(int(item['size']))/1073741824, 2) video_quality, details = get_file_info(name_info=release_info_format(file_name)) source_item = {'name': file_name, 'title': file_name, 'URLName': URLName, 'quality': video_quality, 'size': size, 'size_label': '%.2f GB' % size, 'extraInfo': details, 'url_dl': file_dl, 'id': file_dl, 'downloads': False, 'direct': True, 'source': self.scrape_provider, 'scrape_provider': self.scrape_provider} yield source_item except: pass self.sources = list(_process()) except Exception as e: from modules.kodi_utils import logger logger('FEN alldebrid scraper Exception', e) internal_results(self.scrape_provider, self.sources) return self.sources
def resolve_magnet(self, magnet_url, info_hash, store_to_cloud, title, season, episode): from modules.source_utils import supported_video_extensions, seas_ep_filter, extras_filter try: file_url = None correct_files = [] append = correct_files.append extensions = supported_video_extensions() extras_filtering_list = extras_filter() result = self.instant_transfer(magnet_url) if not 'status' in result or result['status'] != 'success': return None valid_results = [ i for i in result.get('content') if any(i.get('path').lower().endswith(x) for x in extensions) and not i.get('link', '') == '' ] if len(valid_results) == 0: return if season: episode_title = re.sub( r'[^A-Za-z0-9-]+', '.', title.replace('\'', '').replace('&', 'and').replace( '%', '.percent')).lower() for item in valid_results: if seas_ep_filter(season, episode, item['path'].split('/')[-1]): append(item) if len(correct_files) == 0: continue for i in correct_files: compare_link = seas_ep_filter(season, episode, i['path'], split=True) compare_link = re.sub(episode_title, '', compare_link) if not any(x in compare_link for x in extras_filtering_list): file_url = i['link'] break else: file_url = max(valid_results, key=lambda x: int(x.get('size'))).get( 'link', None) if not any(file_url.lower().endswith(x) for x in extensions): file_url = None if file_url: if store_to_cloud: self.create_transfer(magnet_url) return self.add_headers_to_url(file_url) except: return None
def resolve_magnet(self, magnet_url, info_hash, store_to_cloud, title, season, episode): from modules.source_utils import supported_video_extensions, seas_ep_filter, extras_filter try: file_url = None correct_files = [] append = correct_files.append extensions = supported_video_extensions() extras_filtering_list = extras_filter() transfer_id = self.create_transfer(magnet_url) transfer_info = self.list_transfer(transfer_id) valid_results = [ i for i in transfer_info.get('links') if any( i.get('filename').lower().endswith(x) for x in extensions) and not i.get('link', '') == '' ] if len(valid_results) == 0: return if season: episode_title = re.sub( r'[^A-Za-z0-9-]+', '.', title.replace('\'', '').replace('&', 'and').replace( '%', '.percent')).lower() for item in valid_results: if seas_ep_filter(season, episode, item['filename']): append(item) if len(correct_files) == 0: continue for i in correct_files: compare_link = seas_ep_filter(season, episode, i['filename'], split=True) compare_link = re.sub(episode_title, '', compare_link) if not any(x in compare_link for x in extras_filtering_list): media_id = i['link'] break else: media_id = max(valid_results, key=lambda x: x.get('size')).get('link', None) if not store_to_cloud: self.delete_transfer(transfer_id) file_url = self.unrestrict_link(media_id) if not any(file_url.lower().endswith(x) for x in extensions): file_url = None return file_url except Exception: if transfer_id: self.delete_transfer(transfer_id) return None
def create_transfer(self, magnet_url): from modules.source_utils import supported_video_extensions try: extensions = supported_video_extensions() torrent = self.add_magnet(magnet_url) torrent_id = torrent['id'] info = self.torrent_info(torrent_id) files = info['files'] torrent_keys = [ str(item['id']) for item in files if item['path'].lower().endswith(tuple(extensions)) ] torrent_keys = ','.join(torrent_keys) self.add_torrent_select(torrent_id, torrent_keys) return 'success' except: self.delete_torrent(torrent_id) return 'failed'
def display_magnet_pack(self, magnet_url, info_hash): from modules.source_utils import supported_video_extensions try: video_only_items = [] list_file_items = [] append = video_only_items.append extensions = supported_video_extensions() torrent_files = self.check_hash(info_hash) if not info_hash in torrent_files: return None torrent = self.add_magnet(magnet_url) torrent_id = torrent['id'] torrent_files = torrent_files[info_hash]['rd'] torrent_files = [ item for item in torrent_files if self._video_only(item, extensions) ] for item in torrent_files: torrent_keys = item.keys() if len(torrent_keys) == 0: continue append(torrent_keys) video_only_items = max(video_only_items, key=len) torrent_keys = ','.join(video_only_items) self.add_torrent_select(torrent_id, torrent_keys) torrent_info = self.user_cloud_info(torrent_id) list_file_items = [ dict(i, **{'link': torrent_info['links'][idx]}) for idx, i in enumerate( [i for i in torrent_info['files'] if i['selected'] == 1]) ] list_file_items = [{ 'link': i['link'], 'filename': i['path'].replace('/', ''), 'size': i['bytes'] } for i in list_file_items] self.delete_torrent(torrent_id) return list_file_items except Exception: if torrent_id: self.delete_torrent(torrent_id) return None
def display_magnet_pack(self, magnet_url, info_hash): from modules.source_utils import supported_video_extensions try: extensions = supported_video_extensions() transfer_id = self.create_transfer(magnet_url) transfer_info = self.list_transfer(transfer_id) end_results = [] append = end_results.append for item in transfer_info.get('links'): if any( item.get('filename').lower().endswith(x) for x in extensions) and not item.get('link', '') == '': append({ 'link': item['link'], 'filename': item['filename'], 'size': item['size'] }) self.delete_transfer(transfer_id) return end_results except Exception: if transfer_id: self.delete_transfer(transfer_id) return None
def add_uncached_torrent(self, magnet_url, pack=False): from modules.kodi_utils import show_busy_dialog, hide_busy_dialog from modules.source_utils import supported_video_extensions def _return_failed(message=32574, cancelled=False): try: progressDialog.close() except Exception: pass hide_busy_dialog() sleep(500) if cancelled: if confirm_dialog(text=32044, top_space=True): ok_dialog(heading=32733, text=ls(32732) % ls(32054)) else: self.delete_torrent(torrent_id) else: ok_dialog(heading=32733, text=message) return False show_busy_dialog() try: active_count = self.torrents_activeCount() if active_count['nb'] >= active_count['limit']: return _return_failed() except: pass interval = 5 stalled = ('magnet_error', 'error', 'virus', 'dead') extensions = supported_video_extensions() torrent = self.add_magnet(magnet_url) torrent_id = torrent['id'] if not torrent_id: return _return_failed() torrent_info = self.torrent_info(torrent_id) if 'error_code' in torrent_info: return _return_failed() status = torrent_info['status'] line = '%s[CR]%s[CR]%s' if status == 'magnet_conversion': line1 = ls(32737) line2 = torrent_info['filename'] line3 = ls(32738) % torrent_info['seeders'] timeout = 100 progressDialog.create(ls(32733), line % (line1, line2, line3)) while status == 'magnet_conversion' and timeout > 0: progressDialog.update(timeout, line % (line1, line2, line3)) if monitor.abortRequested() == True: return sysexit() try: if progressDialog.iscanceled(): return _return_failed(32736, cancelled=True) except Exception: pass timeout -= interval sleep(1000 * interval) torrent_info = self.torrent_info(torrent_id) status = torrent_info['status'] if any(x in status for x in stalled): return _return_failed() line3 = ls(32738) % torrent_info['seeders'] try: progressDialog.close() except Exception: pass if status == 'downloaded': hide_busy_dialog() return True if status == 'magnet_conversion': return _return_failed() if any(x in status for x in stalled): return _return_failed(str(status)) if status == 'waiting_files_selection': video_files = [] append = video_files.append all_files = torrent_info['files'] for item in all_files: if any(item['path'].lower().endswith(x) for x in extensions): append(item) if pack: try: if len(video_files) == 0: return _return_failed() video_files.sort(key=lambda x: x['path']) torrent_keys = [str(i['id']) for i in video_files] if not torrent_keys: return _return_failed(ls(32736)) torrent_keys = ','.join(torrent_keys) self.add_torrent_select(torrent_id, torrent_keys) ok_dialog(text=ls(32732) % ls(32054)) self.clear_cache() hide_busy_dialog() return True except Exception: return _return_failed() else: try: video = max(video_files, key=lambda x: x['bytes']) file_id = video['id'] except ValueError: return _return_failed() self.add_torrent_select(torrent_id, str(file_id)) sleep(2000) torrent_info = self.torrent_info(torrent_id) status = torrent_info['status'] if status == 'downloaded': hide_busy_dialog() return True file_size = round(float(video['bytes']) / (1000**3), 2) line1 = '%s...' % (ls(32732) % ls(32054)) line2 = torrent_info['filename'] line3 = status progressDialog.create(ls(32733), line % (line1, line2, line3)) while not status == 'downloaded': sleep(1000 * interval) torrent_info = self.torrent_info(torrent_id) status = torrent_info['status'] if status == 'downloading': line3 = ls(32739) % ( file_size, round(float(torrent_info['speed']) / (1000**2), 2), torrent_info['seeders'], torrent_info['progress']) else: line3 = status progressDialog.update(int(float(torrent_info['progress'])), line % (line1, line2, line3)) if monitor.abortRequested() == True: return sys.exit() try: if progressDialog.iscanceled(): return _return_failed(32736, cancelled=True) except: pass if any(x in status for x in stalled): return _return_failed() try: progressDialog.close() except: pass hide_busy_dialog() return True hide_busy_dialog() return False
def resolve_magnet(self, magnet_url, info_hash, store_to_cloud, title, season, episode): from modules.source_utils import supported_video_extensions, seas_ep_filter, extras_filter try: torrent_id, rd_url, match = None, None, False extensions = supported_video_extensions() extras_filtering_list = extras_filter() torrent_files = self.check_hash(info_hash) if not info_hash in torrent_files: return None torrent = self.add_magnet(magnet_url) torrent_id = torrent['id'] torrent_files = torrent_files[info_hash]['rd'] torrent_files = [ item for item in torrent_files if self._video_only(item, extensions) ] if season: episode_title = re.sub( r'[^A-Za-z0-9-]+', '.', title.replace('\'', '').replace('&', 'and').replace( '%', '.percent')).lower() else: m2ts_check = self._m2ts_check(torrent_files) if m2ts_check: m2ts_key, torrent_files = self._m2ts_key_value( torrent_files) else: torrent_files = self.sort_cache_list([ (item, max([i['filesize'] for i in item.values()])) for item in torrent_files ]) for item in torrent_files: try: if season: item_values = [i['filename'] for i in item.values()] for value in item_values: correct_file_check = seas_ep_filter( season, episode, value) if correct_file_check: break if not correct_file_check: continue elif not m2ts_check: item_values = self.sort_cache_list([ (i['filename'], i['filesize']) for i in item.values() ]) for value in item_values: filename = re.sub( r'[^A-Za-z0-9-]+', '.', value.replace('\'', '').replace('&', 'and').replace( '%', '.percent')).lower() if any(x in filename for x in extras_filtering_list): continue break torrent_keys = item.keys() if len(torrent_keys) == 0: continue torrent_keys = ','.join(torrent_keys) self.add_torrent_select(torrent_id, torrent_keys) torrent_info = self.user_cloud_info(torrent_id) if 'error' in torrent_info: continue selected_files = [(idx, i) for idx, i in enumerate([ i for i in torrent_info['files'] if i['selected'] == 1 ])] if season: correct_files = [] correct_file_check = False for value in selected_files: correct_file_check = seas_ep_filter( season, episode, value[1]['path']) if correct_file_check: correct_files.append(value[1]) break if len(correct_files) == 0: continue for i in correct_files: compare_link = seas_ep_filter(season, episode, i['path'], split=True) compare_link = re.sub(episode_title, '', compare_link) if any(x in compare_link for x in extras_filtering_list): continue else: match = True break if match: index = [ i[0] for i in selected_files if i[1]['path'] == correct_files[0]['path'] ][0] break elif m2ts_check: match, index = True, [ i[0] for i in selected_files if i[1]['id'] == m2ts_key ][0] break else: match = False for value in selected_files: filename = re.sub( r'[^A-Za-z0-9-]+', '.', value[1]['path'].rsplit('/', 1)[1].replace( '\'', '').replace('&', 'and').replace( '%', '.percent')).lower() if any(x in filename for x in extras_filtering_list): continue match, index = True, value[0] break if match: break except: pass if match: rd_link = torrent_info['links'][index] file_url = self.unrestrict_link(rd_link) if file_url.endswith('rar'): file_url = None if not any(file_url.lower().endswith(x) for x in extensions): file_url = None if not store_to_cloud: self.delete_torrent(torrent_id) return file_url self.delete_torrent(torrent_id) except Exception: if torrent_id: self.delete_torrent(torrent_id) return None
def pm_torrent_cloud(folder_id=None, folder_name=None): def _builder(): for count, item in enumerate(cloud_files, 1): try: cm = [] cm_append = cm.append file_type = item['type'] name = clean_file_name(item['name']).upper() rename_params = { 'mode': 'premiumize.rename', 'file_type': file_type, 'id': item['id'], 'name': item['name'] } delete_params = {'mode': 'premiumize.delete', 'id': item['id']} if file_type == 'folder': is_folder = True download_string = archive_str delete_params['file_type'] = 'folder' string = folder_str display = '%02d | [B]%s[/B] | [I]%s [/I]' % ( count, folder_str, name) url_params = { 'mode': 'premiumize.pm_torrent_cloud', 'id': item['id'], 'folder_name': normalize(item['name']) } else: is_folder = False download_string = down_str delete_params['file_type'] = 'item' string = file_str url_link = item['link'] if url_link.startswith('/'): url_link = 'https' + url_link size = item['size'] display_size = float(int(size)) / 1073741824 display = '%02d | [B]%s[/B] | %.2f GB | [I]%s [/I]' % ( count, file_str, display_size, name) url_params = { 'mode': 'media_play', 'url': url_link, 'media_type': 'video' } down_file_params = { 'mode': 'downloader', 'name': item['name'], 'url': url_link, 'action': 'cloud.premiumize', 'image': default_pm_icon } cm_append((download_string, 'RunPlugin(%s)' % build_url(down_file_params))) cm_append((rename_str % file_type.capitalize(), 'RunPlugin(%s)' % build_url(rename_params))) cm_append(('[B]%s %s[/B]' % (delete_str, string.capitalize()), 'RunPlugin(%s)' % build_url(delete_params))) url = build_url(url_params) listitem = make_listitem() listitem.setLabel(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_pm_icon, 'poster': default_pm_icon, 'thumb': default_pm_icon, 'fanart': fanart, 'banner': default_pm_icon }) yield (url, listitem, is_folder) except: pass __handle__ = int(argv[1]) folder_str, file_str, down_str, archive_str, rename_str, delete_str = ls( 32742).upper(), ls(32743).upper(), ls(32747), ls(32982), ls(32748), ls( 32785) extensions = supported_video_extensions() cloud_files = Premiumize.user_cloud(folder_id)['content'] cloud_files = [ i for i in cloud_files if ('link' in i and i['link'].lower().endswith(tuple(extensions))) or i['type'] == 'folder' ] cloud_files.sort(key=lambda k: k['name']) cloud_files.sort(key=lambda k: k['type'], reverse=True) kodi_utils.add_items(__handle__, list(_builder())) kodi_utils.set_content(__handle__, 'files') kodi_utils.end_directory(__handle__) kodi_utils.set_view_mode('view.premium')
def __init__(self, scrape_provider, scraper_name): self.scrape_provider = scrape_provider self.scraper_name = scraper_name self.title_filter = filter_by_name('folders') self.extensions = supported_video_extensions() self.sources, self.scrape_results = [], []
def rd_downloads(): def _builder(): for count, item in enumerate(my_downloads, 1): try: cm = [] cm_append = cm.append datetime_object = jsondate_to_datetime(item['generated'], '%Y-%m-%dT%H:%M:%S.%fZ', remove_time=True) filename = item['filename'] name = clean_file_name(filename).upper() size = float(int(item['filesize'])) / 1073741824 display = '%02d | %.2f GB | %s | [I]%s [/I]' % ( count, size, datetime_object, name) url_link = item['download'] url_params = { 'mode': 'media_play', 'url': url_link, 'media_type': 'video' } down_file_params = { 'mode': 'downloader', 'name': name, 'url': url_link, 'action': 'cloud.realdebrid_direct', 'image': default_rd_icon } delete_params = { 'mode': 'real_debrid.delete', 'id': item['id'], 'cache_type': 'download' } cm_append( (down_str, 'RunPlugin(%s)' % build_url(down_file_params))) cm_append( ('[B]%s %s[/B]' % (delete_str, file_str.capitalize()), 'RunPlugin(%s)' % build_url(delete_params))) url = build_url(url_params) listitem = make_listitem() listitem.setLabel(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_rd_icon, 'poster': default_rd_icon, 'thumb': default_rd_icon, 'fanart': fanart, 'banner': default_rd_icon }) yield (url, listitem, True) except: pass __handle__ = int(argv[1]) try: my_downloads = RealDebrid.downloads() except: return extensions = supported_video_extensions() my_downloads = [ i for i in my_downloads if i['download'].lower().endswith(tuple(extensions)) ] file_str, down_str, delete_str = ls(32743), ls(32747), ls(32785) kodi_utils.add_items(__handle__, list(_builder())) kodi_utils.set_content(__handle__, 'files') kodi_utils.end_directory(__handle__) kodi_utils.set_view_mode('view.premium')
def browse_rd_cloud(folder_id): def _builder(): for count, item in enumerate(pack_info, 1): try: cm = [] name = item['path'] if name.startswith('/'): name = name.split('/')[-1] name = clean_file_name(name).upper() url_link = item['url_link'] if url_link.startswith('/'): url_link = 'http' + url_link size = float(int(item['bytes'])) / 1073741824 display = '%02d | [B]%s[/B] | %.2f GB | [I]%s [/I]' % ( count, file_str, size, name) url_params = { 'mode': 'real_debrid.resolve_rd', 'url': url_link, 'play': 'true' } url = build_url(url_params) down_file_params = { 'mode': 'downloader', 'name': name, 'url': url_link, 'action': 'cloud.realdebrid', 'image': default_rd_icon } cm.append( (down_str, 'RunPlugin(%s)' % build_url(down_file_params))) listitem = make_listitem() listitem.setLabel(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_rd_icon, 'poster': default_rd_icon, 'thumb': default_rd_icon, 'fanart': fanart, 'banner': default_rd_icon }) listitem.setInfo('video', {}) yield (url, listitem, False) except: pass __handle__ = int(argv[1]) torrent_files = RealDebrid.user_cloud_info(folder_id) extensions = supported_video_extensions() file_info = [ i for i in torrent_files['files'] if i['path'].lower().endswith(tuple(extensions)) ] file_urls = torrent_files['links'] for c, i in enumerate(file_info): try: i.update({'url_link': file_urls[c]}) except: pass pack_info = sorted(file_info, key=lambda k: k['path']) file_str, down_str = ls(32743).upper(), ls(32747) kodi_utils.add_items(__handle__, list(_builder())) kodi_utils.set_content(__handle__, 'files') kodi_utils.end_directory(__handle__) kodi_utils.set_view_mode('view.premium')
def add_uncached_torrent(self, magnet_url, pack=False): from modules.kodi_utils import show_busy_dialog, hide_busy_dialog from modules.source_utils import supported_video_extensions def _transfer_info(transfer_id): info = self.transfers_list() if 'status' in info and info['status'] == 'success': for item in info['transfers']: if item['id'] == transfer_id: return item return {} def _return_failed(message=32574, cancelled=False): try: progressDialog.close() except Exception: pass hide_busy_dialog() sleep(500) if cancelled: if confirm_dialog(heading=32733, text=32044, top_space=True): ok_dialog(heading=32733, text=ls(32732) % ls(32061)) else: self.delete_transfer(transfer_id) else: ok_dialog(heading=32733, text=message) return False show_busy_dialog() extensions = supported_video_extensions() transfer_id = self.create_transfer(magnet_url) if not transfer_id['status'] == 'success': return _return_failed(transfer_id.get('message')) transfer_id = transfer_id['id'] transfer_info = _transfer_info(transfer_id) if not transfer_info: return _return_failed() if pack: self.clear_cache() hide_busy_dialog() ok_dialog(text=ls(32732) % ls(32061)) return True interval = 5 line = '%s[CR]%s[CR]%s' line1 = '%s...' % (ls(32732) % ls(32061)) line2 = transfer_info['name'] line3 = transfer_info['message'] progressDialog.create(ls(32733), line % (line1, line2, line3)) while not transfer_info['status'] == 'seeding': sleep(1000 * interval) transfer_info = _transfer_info(transfer_id) line3 = transfer_info['message'] progressDialog.update(int(float(transfer_info['progress']) * 100), line % (line1, line2, line3)) if monitor.abortRequested() == True: return sysexit() try: if progressDialog.iscanceled(): return _return_failed(ls(32736), cancelled=True) except Exception: pass if transfer_info.get('status') == 'stalled': return _return_failed() sleep(1000 * interval) try: progressDialog.close() except Exception: pass hide_busy_dialog() return True
def pm_transfers(): def _builder(): for count, item in enumerate(transfer_files, 1): try: cm = [] file_type = 'folder' if item['file_id'] is None else 'file' name = clean_file_name(item['name']).upper() status = item['status'] progress = item['progress'] if status == 'finished': progress = 100 else: try: progress = re.findall(r'\.{0,1}(\d+)', str(progress))[0][:2] except: progress = '' if file_type == 'folder': is_folder = True if status == 'finished' else False display = '%02d | %s%% | [B]%s[/B] | [I]%s [/I]' % ( count, str(progress), folder_str, name) url_params = { 'mode': 'premiumize.pm_torrent_cloud', 'id': item['folder_id'], 'folder_name': normalize(item['name']) } else: is_folder = False details = Premiumize.get_item_details(item['file_id']) url_link = details['link'] if url_link.startswith('/'): url_link = 'https' + url_link size = details['size'] display_size = float(int(size)) / 1073741824 display = '%02d | %s%% | [B]%s[/B] | %.2f GB | [I]%s [/I]' % ( count, str(progress), file_str, display_size, name) url_params = { 'mode': 'media_play', 'url': url_link, 'media_type': 'video' } down_file_params = { 'mode': 'downloader', 'name': item['name'], 'url': url_link, 'db_type': 'cloud.premiumize', 'image': default_pm_icon } cm.append((down_str, 'RunPlugin(%s)' % build_url(down_file_params))) url = build_url(url_params) listitem = make_listitem() listitem.setLabel(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_pm_icon, 'poster': default_pm_icon, 'thumb': default_pm_icon, 'fanart': fanart, 'banner': default_pm_icon }) yield (url, listitem, is_folder) except: pass __handle__ = int(argv[1]) extensions = supported_video_extensions() transfer_files = Premiumize.transfers_list()['transfers'] folder_str, file_str, down_str = ls(32742).upper(), ls(32743).upper(), ls( 32747) kodi_utils.add_items(__handle__, list(_builder())) kodi_utils.set_content(__handle__, 'files') kodi_utils.end_directory(__handle__) kodi_utils.set_view_mode('view.premium')