def __init__(self, url, idFilme, pastaData, temporada, episodio, nome, ano, logo, serieNome): xbmc.Player.__init__(self) self.url=url self.temporada=temporada self.episodio=episodio self.playing = True self.tempo = 0 self.tempoTotal = 0 self.idFilme = idFilme self.pastaData = xbmc.translatePath(pastaData) self.nome = nome self.ano = ano self.logo = logo self.serieNome = serieNome if not xbmcvfs.exists(os.path.join(pastaData,'tracker')): xbmcvfs.mkdirs(os.path.join(pastaData,'tracker')) if self.temporada != 0 and self.episodio != 0: self.pastaVideo = os.path.join(self.pastaData,'tracker',str(self.idFilme)+'S'+str(self.temporada)+'x'+str(self.episodio)+'.mrpiracy') self.content = 'episode' else: self.pastaVideo = os.path.join(self.pastaData,'tracker',str(self.idFilme)+'.mrpiracy') self.content = 'movie'
def Download(file_name, file_directory, season, episode): subtitle_list = [] ## Cleanup temp dir, we recomend you download/unzip your subs in temp folder and ## pass that to XBMC to copy and activate if xbmcvfs.exists(__temp__): shutil.rmtree(__temp__) xbmcvfs.mkdirs(__temp__) file_data = geturl('http://subsfactory.it/subtitle/index.php?action=downloadfile&filename=' + file_name + '&directory=' + file_directory +'&', None) subs_files = [] # Check if subtitle is downloaded if file_data: # Save file to the temp folder local_file_handle = open(os.path.join(__temp__, 'subsfactory.tmp'), 'wb') local_file_handle.write(file_data) local_file_handle.close() #Check archive type (rar/zip/else) through the file header (rar=Rar!, zip=PK) tmp_file = open(os.path.join(__temp__, 'subsfactory.tmp'), 'rb') tmp_file.seek(0) if tmp_file.read(1) == 'R': ext = 'rar' packed = True else: tmp_file.seek(0) if tmp_file.read(1) == 'P': ext = 'zip' packed = True else: ext = 'srt' packed = False tmp_file.close() # Rename file with the good ext os.rename(os.path.join(__temp__, 'subsfactory.tmp'), os.path.join(__temp__, 'subsfactory.' + ext)) if packed: # Extract subs xbmc.sleep(500) xbmc.executebuiltin(('XBMC.Extract(' + os.path.join(__temp__, 'subsfactory.' + ext) + ',' + __temp__ +')').encode('utf-8'), True) if season is not None: episode_file = searchEpisode(season, episode) if episode_file is not None: subs_files.append(episode_file) else: folders = [__temp__] for folder in folders: newFolders = getFolders(folder) for newFolder in newFolders: folders.append(newFolder) for file in os.listdir(folder): if os.path.splitext(file)[1] in allowed_exts: subs_files.append(os.path.join(folder, file)) else: subs_files.append(os.path.join(__temp__, 'subsfactory.' + ext)) # Send the subtitle list to xbmc return subs_files
def writeMediaList(url, name, cType='Other'): utils.addon_log('writeMediaList') existInList = False thelist = [] thefile = xbmc.translatePath(os.path.join(profile, 'MediaList.xml')) theentry = '|'.join([cType, name.decode("utf-8"), url]) + '\n' if not xbmcvfs.exists(profile): xbmcvfs.mkdirs(profile) if not xbmcvfs.exists(thefile): open(thefile, 'a').close() fle = codecs.open(thefile, "r", 'UTF-8') thelist = fle.readlines() fle.close() del fle if len(thelist) > 0: for i in thelist: if i.split('|',2)[1] == name: thelist = stringUtils.replaceStringElem(thelist, theentry, theentry) existInList = True if existInList != True: thelist.append(theentry) with open(thefile.decode("utf-8"), 'w') as output_file: for linje in thelist: if not linje.startswith('\n'): output_file.write(linje.strip().encode('utf-8') + '\n') else: output_file.write(linje.strip())
def makeSTRM(filepath, filename, url): filepath = stringUtils.multiRstrip(filepath.decode("utf-8")) filename = filename.decode("utf-8") utils.addon_log('makeSTRM') filepath = os.path.join(STRM_LOC, filepath) if not xbmcvfs.exists(filepath): xbmcvfs.mkdirs(filepath) fullpath = xbmc.translatePath(os.path.join(filepath, filename + '.strm')) if xbmcvfs.exists(fullpath): if addon.getSetting('Clear_Strms') == 'true': x = 0 #xbmcvfs.delete(fullpath) else: return fullpath else: try: fle = open(fullpath.encode("utf-8"), "w") except: fle = open(fullpath.decode("utf-8"), "w") pass fle.write("%s" % url) fle.close() del fle return fullpath
def saveTorrent(self, torrentUrl): #if not xbmcvfs.exists(torrentUrl) or re.match("^http.+$", torrentUrl): if re.match("^magnet\:.+$", torrentUrl): self.magnetLink = torrentUrl self.magnetToTorrent(torrentUrl) self.magnetLink = None return self.torrentFile else: if not xbmcvfs.exists(self.torrentFilesPath): xbmcvfs.mkdirs(self.torrentFilesPath) torrentFile = os.path.join(self.torrentFilesPath, self.md5(torrentUrl) + '.torrent') try: if not re.match("^[htps]+?://.+$|^://.+$", torrentUrl): log('xbmcvfs.File for %s' % torrentUrl) content = xbmcvfs.File(torrentUrl, "rb").read() else: log('request for %s' % torrentUrl) content = self.makeRequest(torrentUrl) localFile = xbmcvfs.File(torrentFile, "w+b") localFile.write(content) localFile.close() except Exception, e: log('Unable to rename torrent file from %s to %s in AnteoLoader::saveTorrent. Exception: %s' % (torrentUrl, torrentFile, str(e))) return
def mkdirs(path): # Will create all folders in path if needed try: xbmcvfs.mkdirs(path) except: os.makedirs(path) return
def playlist_path(pcs_file_path, stream): user_info = get_user_info() user_name = user_info['username'] user_cookie = user_info['cookie'] user_tokens = user_info['tokens'] if stream: playlist_data = pcs.get_streaming_playlist(user_cookie, pcs_file_path, stream) if playlist_data: raw_dir = os.path.dirname(pcs_file_path) m = re.search('\/(.*)', raw_dir) dirname = m.group(1) basename = os.path.basename(pcs_file_path) r = re.search('(.*)\.(.*)$', basename) filename = ''.join([r.group(1), stream, '.m3u8']) dirpath = os.path.join(utils.data_dir(), user_name, dirname) if not xbmcvfs.exists(dirpath): xbmcvfs.mkdirs(dirpath) filepath = os.path.join(dirpath, filename) tmpFile = xbmcvfs.File(filepath, 'w') tmpFile.write(bytearray(playlist_data, 'utf-8')) return filepath else: dialog.notification('', u'无法打开视频,请尝试其他清晰度', xbmcgui.NOTIFICATION_INFO, 6000) return None else: url = pcs.get_download_link(user_cookie, user_tokens, pcs_file_path) return url
def setThumbnail(self, service, url=''): #load cachePath if not already loaded if self.cachePath == '': self.cachePath = service.settings.cachePath # there is no cache path setting or the setting is unset -- we should assume user does not want to use caching if not service.settings.cacheThumbnails or self.cachePath == '': if url == '': return self.package.file.thumbnail else: return url if url == '': url = self.package.file.thumbnail #simply no thumbnail if url == '': return "" #user doesn't want to cache thumbnails if not service.settings.cacheThumbnails: return url cachePath = str(self.cachePath) + str(self.package.file.id) + '/' cacheFile = str(self.cachePath) + str(self.package.file.id) + '.jpg' if not xbmcvfs.exists(cachePath): xbmcvfs.mkdirs(cachePath) if not xbmcvfs.exists(cacheFile): cacheFile = service.downloadGeneralFile(url, cacheFile) if cacheFile is None: return url return cacheFile
def sync(self): if self._state == self.OBJECT_SKIP: return try: self._state = self.inSync() if self._state == self.OBJECT_2_DOWNLOAD: log_debug('Create folder: %s'%self._localPath) xbmcvfs.mkdirs( self._localPath.encode("utf-8") ) self.updateTimeStamp() elif self._state == self.OBJECT_2_UPLOAD: log_error('Can\'t upload folder: %s'%self._localPath) #TODO Add files if new files found local #TODO: modify timestamp of dir... elif self._state == self.OBJECT_2_REMOVE: log_debug('Remove folder: %s'%self._localPath) shutil.rmtree(self._localPath) elif self._state == self.OBJECT_ADD_CHILD: #TODO pass elif self._state == self.OBJECT_IN_SYNC: pass else: log_error('Unknown folder status(%s) for : %s!'%(self._state, self.path)) except Exception, e: log_error('Exception occurred for folder %s' % self._localPath) log_error( traceback.format_exc() ) if(self._failure): #failure happened before... So skip this item in all the next syncs! self._state = self.OBJECT_SKIP log_error('Skipping folder in next syncs: %s'% self._localPath) self._failure = True
def get_database(self): '''get reference to our sqllite database - performs basic integrity check''' addon = xbmcaddon.Addon(ADDON_ID) dbpath = addon.getAddonInfo('profile') dbfile = xbmc.translatePath("%s/simplecache.db" % dbpath).decode('utf-8') if not xbmcvfs.exists(dbpath): xbmcvfs.mkdirs(dbpath) del addon try: connection = sqlite3.connect(dbfile, timeout=30, isolation_level=None) connection.execute('SELECT * FROM simplecache LIMIT 1') return connection except Exception as error: # our database is corrupt or doesn't exist yet, we simply try to recreate it if xbmcvfs.exists(dbfile): xbmcvfs.delete(dbfile) try: connection = sqlite3.connect(dbfile, timeout=30, isolation_level=None) connection.execute( """CREATE TABLE IF NOT EXISTS simplecache( id TEXT UNIQUE, expires INTEGER, data TEXT, checksum INTEGER)""") return connection except Exception as error: self.log_msg("Exception while initializing database: %s" % str(error), xbmc.LOGWARNING) self.close() return None
def ensure_workdir(workdir): # Cleanup temp dir, we recommend you download/unzip your subs in temp # folder and pass that to XBMC to copy and activate if xbmcvfs.exists(workdir): removeAll(workdir) xbmcvfs.mkdirs(workdir) return xbmcvfs.exists(workdir)
def add_to_library(video_type, url, title, img, year, imdbnum, movie_num=''): try: IW_addon.log('Creating .strm for %s %s %s %s %s %s' % (video_type, title, imdbnum, url, img, year)) except: pass if video_type == 'tvshow': save_path = IW_addon.get_setting('tvshow-folder') save_path = xbmc.translatePath(save_path) strm_string = IW_addon.build_plugin_url( {'mode': 'NightlyNewsSubMenu','dialog': '1'}) if year: title = '%s (%s)' % (title, year) filename = filename_from_title(title + ' s1e1', 'movie') title = re.sub(r'[^\w\-_\. ]', '_', title) titles = title final_path = os.path.join(save_path, title, filename) final_path = xbmc.makeLegalFilename(final_path) if not xbmcvfs.exists(os.path.dirname(final_path)): try: try: xbmcvfs.mkdirs(os.path.dirname(final_path)) except: os.path.mkdir(os.path.dirname(final_path)) except Exception, e: try: IW_addon.log('Failed to create directory %s' % final_path) except: pass try: file_desc = xbmcvfs.File(final_path, 'w') file_desc.write(strm_string) file_desc.close() except Exception, e: IW_addon.log('Failed to create .strm file: %s\n%s' % (final_path, e))
def _make_dir(self, path, dir): subpath = os.path.join(path, dir) try: if not xbmcvfs.exists(subpath): xbmcvfs.mkdirs(subpath) except: if not os.path.exists(subpath): os.makedirs(subpath) return subpath
def __init__(self, path, **kwargs): """ A :class:`pyfscache.FSCache` object is instantiated with a `path` and optional lifetime keyword arguments: .. code-block:: python >>> c = FSCache('cache/dir', days=7) Inits a new FSCache instance at the given `path`. If the `path` doesn't exist, one is made. New objects added to the cache are given a lifetime, expressed in the keyword arguments `kwargs` with potential keys of ``years``, ``months``, ``weeks``, ``days``, ``hours``, ``minutes``, ``seconds``. See :func:`to_seconds`. If no keyword arguments are given, then the lifetime is considered to be infinite. Creating a :class:`pyfscache.FSCache` object does not purge the cache in `path` if the cache already exists. Instead, the :class:`pyfscache.FSCache` object will begin to use the cache, loading items and storing items as necessary. """ if kwargs: self._lifetime = to_seconds(**kwargs) if self._lifetime <= 0: msg = "Lifetime (%s seconds) is 0 or less." % self._lifetime raise LifetimeError, msg else: self._lifetime = None self._loaded = {} self._path = os.path.abspath(path) if not xbmcvfs.exists(self._path): xbmcvfs.mkdirs(self._path)
def writeConfig(cfile, value=''): cfgfile = os.path.join(configpath, cfile) cfglockfile = os.path.join(configpath, cfile + '.lock') if not xbmcvfs.exists(configpath): xbmcvfs.mkdirs(configpath) while True: if not xbmcvfs.exists(cfglockfile): l = xbmcvfs.File(cfglockfile, 'w') l.write(str(time.time())) l.close() if value == '': xbmcvfs.delete(cfgfile) else: f = xbmcvfs.File(cfgfile, 'w') f.write(value.__str__()) f.close() xbmcvfs.delete(cfglockfile) xbmcvfs.delete(cfglockfile) return True else: l = xbmcvfs.File(cfglockfile) modified = float(l.read()) l.close() if time.time() - modified > 0.1: xbmcvfs.delete(cfglockfile)
def add_item_to_library(self, item_path, item_url): error = False new = False if item_path: item_path = xbmc.translatePath(item_path) dir = os.path.dirname(item_path) if not xbmcvfs.exists(dir): try: xbmcvfs.mkdirs(dir) except Exception, e: error = True print('Failed to create directory 1', dir) if not xbmcvfs.exists(dir): error = True print('Failed to create directory 2', dir) if not xbmcvfs.exists(item_path): try: file_desc = xbmcvfs.File(item_path, 'w') file_desc.write(item_url) file_desc.close() new = True except Exception, e: print('Failed to create .strm file: ', item_path, e) error = True
def setCC(self, service): if not constants.CONST.CC: return #load cachePath if not already loaded if self.cachePath == '': self.cachePath = service.settings.cachePath # there is no cache path setting or the setting is unset -- we should assume user does not want to use caching # CC files need to be cached (so they can be converted to SRT) -- don't do anything if we don't have the cachePath if self.cachePath == '': return else: cachePath = str(self.cachePath) + '/' + str(self.package.file.id)+'/' if not xbmcvfs.exists(cachePath): xbmcvfs.mkdirs(cachePath) cachePath = str(cachePath) + str(self.package.file.id) cc = service.getTTS(self.package.file.srtURL) if cc: for file in cc: if not xbmcvfs.exists(cachePath + str(file[0])): service.downloadTTS(file[1], str(cachePath) + str(file[0])) self.srt.append(str(cachePath) + str(file[0]))
def setSRT(self, service): if not constants.CONST.SRT: return #load cachePath if not already loaded if not service.settings.cacheSRT and self.cachePath == '': self.cachePath = service.settings.cachePath #only makes sense to cache SRT if the cachePath exists if service.settings.cacheSRT and self.cachePath != '': cachePath = str(self.cachePath) + '/' + str(self.package.file.id)+'/' if not xbmcvfs.exists(cachePath): xbmcvfs.mkdirs(cachePath) srt = service.getSRT(self.package) if srt: for file in srt: if not xbmcvfs.exists(str(cachePath) + str(file[0])): service.downloadGeneralFile(file[1], str(cachePath) + str(file[0])) self.srt.append(str(cachePath) + str(file[0])) #fetch SRT URLs but we won't cache the files else: srt = service.getSRT(self.package) if srt: for file in srt: self.srt.append(str(file[1]) + '|' + service.getHeadersEncoded())
def download(id, url, filename, search_string=""): subtitle_list = [] exts = [".srt", ".sub", ".txt", ".smi", ".ssa", ".ass"] ## Cleanup temp dir, we recomend you download/unzip your subs ## in temp folder and pass that to XBMC to copy and activate if xbmcvfs.exists(__temp__): shutil.rmtree(__temp__) xbmcvfs.mkdirs(__temp__) filename = os.path.join(__temp__, filename + ".zip") req = urllib2.Request(url, headers={"User-Agent": "Kodi-Addon"}) sub = urllib2.urlopen(req).read() with open(filename, "wb") as subFile: subFile.write(sub) subFile.close() xbmc.sleep(500) xbmc.executebuiltin( ( 'XBMC.Extract("%s","%s")' % (filename, __temp__,) ).encode('utf-8'), True) for file in xbmcvfs.listdir(__temp__)[1]: file = os.path.join(__temp__, file) if os.path.splitext(file)[1] in exts: if search_string and string.find( string.lower(file), string.lower(search_string) ) == -1: continue log(__name__, "=== returning subtitle file %s" % file) subtitle_list.append(file) return subtitle_list
def __init__(self): self.__dict__ = self._shared_state client_info = clientinfo.ClientInfo() self.emby = embyserver.Read_EmbyServer() version = client_info.get_version() device_name = client_info.get_device_name() device_id = client_info.get_device_id() self._connect = connectionmanager.ConnectionManager(appName="Kodi", appVersion=version, deviceName=device_name, deviceId=device_id) path = xbmc.translatePath( "special://profile/addon_data/plugin.video.emby/").decode('utf-8') if not xbmcvfs.exists(path): xbmcvfs.mkdirs(path) self._connect.setFilePath(path) if window('emby_state.json'): self.state = window('emby_state.json') elif not self.state: self.state = self._connect.connect() log.info("Started with: %s", self.state) window('emby_state.json', value=self.state)
def unzip(zip_file,path): import shutil import zipfile zip_file = try_decode(zip_file) path = try_decode(path) logMsg("START UNZIP of file %s to path %s " %(zipfile,path)) f = zipfile.ZipFile(zip_file, 'r') for fileinfo in f.infolist(): filename = fileinfo.filename filename = try_decode(filename) logMsg("unzipping " + filename) if "\\" in filename: xbmcvfs.mkdirs(os.path.join(path,filename.rsplit("\\", 1)[0])) elif "/" in filename: xbmcvfs.mkdirs(os.path.join(path,filename.rsplit("/", 1)[0])) filename = os.path.join(path,filename) logMsg("unzipping " + filename) try: #newer python uses unicode outputfile = open(filename, "wb") except: #older python uses utf-8 outputfile = open(filename.encode("utf-8"), "wb") #use shutil to support non-ascii formatted files in the zip shutil.copyfileobj(f.open(fileinfo.filename), outputfile) outputfile.close() f.close() logMsg("UNZIP DONE of file %s to path %s " %(zipfile,path))
def Download(ID,lang,filename,key): URLBASE=__addon__.getSetting("BASEURL") url=URLBASE+"/he/api/subtitle/download/"+lang+"/?sub_id="+ID+"&v="+ urllib.quote(filename, safe='')+"&key="+key subtitle_list = [] if xbmcvfs.exists(__temp__): shutil.rmtree(__temp__) xbmcvfs.mkdirs(__temp__) the_page=get_token() values = {'token' : the_page['token'], 'user': the_page['user'] } data = urllib.urlencode(values) req = urllib2.Request(url, data) response = urllib2.urlopen(req) zipdata= response.read() zipfilename=os.path.join(__temp__,filename) output = open(zipfilename,'wb') output.write(zipdata) output.close() zfobj = zipfile.ZipFile(zipfilename) for subname in zfobj.namelist(): if subname.find(".srt") >0: zfobj.extract(subname,__temp__) subtitle_list.append(os.path.join(__temp__,subname)) return subtitle_list
def download_subtitle(self, url): url = BASE_URL + url (response, srt) = self.__get_url(url) if not hasattr(response, 'info') or 'Content-Disposition' not in response.info(): return cd = response.info()['Content-Disposition'] r = re.search('filename="(.*)"', cd) if r: filename = r.group(1) else: filename = 'addic7ed_subtitle.srt' filename = re.sub('[^\x00-\x7F]', '', filename) final_path = os.path.join(kodi.get_setting('subtitle-folder'), filename) final_path = kodi.translate_path(final_path) if not xbmcvfs.exists(os.path.dirname(final_path)): try: try: xbmcvfs.mkdirs(os.path.dirname(final_path)) except: os.mkdir(os.path.dirname(final_path)) except: log_utils.log('Failed to create directory %s' % os.path.dirname(final_path), log_utils.LOGERROR) raise with open(final_path, 'w') as f: f.write(srt) return final_path
def saveTorrent(self, torrentUrl): #if not xbmcvfs.exists(torrentUrl) or re.match("^http.+$", torrentUrl): if re.match("^magnet\:.+$", torrentUrl): self.magnetLink = torrentUrl self.magnetToTorrent(torrentUrl) self.magnetLink = None return self.torrentFile else: if not xbmcvfs.exists(self.torrentFilesPath): xbmcvfs.mkdirs(self.torrentFilesPath) torrentFile = os.path.join(self.torrentFilesPath, self.md5(torrentUrl) + '.torrent') try: if not re.match("^http\:.+$", torrentUrl): content = xbmcvfs.File(torrentUrl, "rb").read() else: request = urllib2.Request(torrentUrl) request.add_header('Referer', torrentUrl) request.add_header('Accept-encoding', 'gzip') result = urllib2.urlopen(request) if result.info().get('Content-Encoding') == 'gzip': buf = StringIO(result.read()) decomp = zlib.decompressobj(16 + zlib.MAX_WBITS) content = decomp.decompress(buf.getvalue()) else: content = result.read() localFile = xbmcvfs.File(torrentFile, "w+b") localFile.write(content) localFile.close() except Exception, e: log('Unable to rename torrent file from %s to %s in InposLoader::saveTorrent. Exception: %s' % (torrentUrl, torrentFile, str(e))) return
def mkdirs(fle): FileAccess.log('mkdirs ' + fle) try: xbmcvfs.mkdirs(fle) return True except: return False
def add2lib( url, name, infol, img, fanart, year ): img = 'http://oi62.tinypic.com/dvgj1t.jpg' addon.log('Add To Library %s , %s, %s' % (name,year,url)) path = xbmc.translatePath( addon.get_setting('movie-folder') ) string = 'plugin://plugin.video.mutttsnutz/?mode=playstream&url='+url+'&name='+name+'&infol=' filename = '%s.strm' % name path = xbmc.makeLegalFilename( xbmc.translatePath(os.path.join( path, name, filename ))) if not xbmcvfs.exists(os.path.dirname(path)): try: try: xbmcvfs.mkdirs(os.path.dirname(path)) except: os.mkdir(os.path.dirname(path)) except: addon.log('FAILED to create directory') if xbmcvfs.exists(path): addon.log( name+' Already in the library' ) notification( addon.get_name()+' allready added', name, img) return notification( addon.get_name()+' adding to library', name+' adding to library', img) strm = xbmcvfs.File(path, 'w') strm.write(string) strm.close() xbmc.executebuiltin("UpdateLibrary(video)")
def resolve(url): actions = [ ("plugin://plugin.video.yatp/?action=play&torrent=%s", "plugin.video.yatp", "YATP-Yet Another Torrent Player"), ("plugin://plugin.video.quasar/play?uri=%s", "plugin.video.quasar", "Quasar"), ] if not xbmcvfs.exists(os.path.dirname(torrent_path)): try: xbmcvfs.mkdirs(os.path.dirname(torrent_path)) except: os.mkdir(os.path.dirname(torrent_path)) file = urllib2.urlopen(url) output = open(torrent_path, "wb") output.write(file.read()) output.close() choice = int(control.setting("torrentPlayer")) action = actions[choice] if choice == 0: url = torrent_path if addonInstaller.isInstalled(action[1]): return action[0] % url else: control.infoDialog( "Torrent player not installed. Install it or select a different torrent player.", heading=action[2], time=6000, ) return ""
def setAddonsettings(): if not xbmcvfs.exists(SETTING("pvrthumbspath")): xbmcvfs.mkdirs(SETTING("pvrthumbspath")) if not xbmcvfs.exists("special://profile/addon_data/script.skin.helper.service/musicart/"): xbmcvfs.mkdirs("special://profile/addon_data/script.skin.helper.service/musicart/") #get the addonsettings and store them in memory WINDOW.setProperty("SkinHelper.pvrthumbspath",SETTING("pvrthumbspath")) WINDOW.setProperty("SkinHelper.cacheRecordings",SETTING("cacheRecordings")) WINDOW.setProperty("SkinHelper.cacheGuideEntries",SETTING("cacheGuideEntries")) WINDOW.setProperty("SkinHelper.customRecordingsPath",SETTING("customRecordingsPath")) WINDOW.setProperty("SkinHelper.useTMDBLookups",SETTING("useTMDBLookups")) WINDOW.setProperty("SkinHelper.useGoogleLookups",SETTING("useGoogleLookups")) WINDOW.setProperty("SkinHelper.useYoutubeLookups",SETTING("useYoutubeLookups")) WINDOW.setProperty("SkinHelper.useLocalLibraryLookups",SETTING("useLocalLibraryLookups")) WINDOW.setProperty("SkinHelper.customlookuppath",SETTING("customlookuppath")) WINDOW.setProperty("SkinHelper.useFanArtTv",SETTING("useFanArtTv")) WINDOW.setProperty("SkinHelper.ignorechannels",SETTING("ignorechannels")) WINDOW.setProperty("SkinHelper.ignoretitles",SETTING("ignoretitles")) WINDOW.setProperty("SkinHelper.stripwords",SETTING("stripwords")) WINDOW.setProperty("SkinHelper.directory_structure",SETTING("directory_structure")) WINDOW.setProperty("SkinHelper.lastUpdate","%s" %datetime.now()) WINDOW.setProperty("SkinHelper.enablewallbackgrounds",SETTING("enablewallbackgrounds")) WINDOW.setProperty("SkinHelper.enableMusicArtScraper",SETTING("enableMusicArtScraper")) WINDOW.setProperty("SkinHelper.downloadMusicArt",SETTING("downloadMusicArt")) WINDOW.setProperty("SkinHelper.enableLocalMusicArtLookup",SETTING("enableLocalMusicArtLookup")) WINDOW.setProperty("SkinHelper.enableDebugLog",SETTING("enableDebugLog")) WINDOW.setProperty("SkinHelper.maxNumFanArts",SETTING("maxNumFanArts")) WINDOW.setProperty("SkinHelper.splittitlechar",SETTING("splittitlechar")) WINDOW.setProperty("SkinHelper.enablePVRThumbsRecordingsOnly",SETTING("enablePVRThumbsRecordingsOnly")) WINDOW.setProperty("SkinHelper.preferOnlineMusicArt",SETTING("preferOnlineMusicArt")) WINDOW.setProperty("SkinHelper.enableWidgetsArtworkLookups",SETTING("enableWidgetsArtworkLookups")) WINDOW.setProperty("SkinHelper.enableSpecialsInWidgets",SETTING("enableSpecialsInWidgets")) WINDOW.setProperty("SkinHelper.enableWidgetsAlbumBrowse",SETTING("enableWidgetsAlbumBrowse"))
def __init__(self): run = Prop("run") if (run) and (time.time() < float(run) + 3): return Prop("run", str(time.time())) Prop("stamp", _stamp) self.once = True self.abort = False self.mesg = None self.station = None self.stations = None self.songs = {} self.pithos = mypithos.Pithos() self.player = xbmc.Player() self.playlist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC) self.ahead = {} self.queue = collections.deque() self.prof = Val("prof") self.wait = {"auth": 0, "stations": 0, "flush": 0, "scan": 0, "next": 0} self.silent = xbmc.translatePath("special://home/addons/%s/resources/media/silent.m4a" % _id) musicbrainzngs.set_useragent("kodi.%s" % _id, Val("version")) xbmcvfs.mkdirs(xbmc.translatePath(Val("cache")).decode("utf-8")) xbmcvfs.mkdirs(xbmc.translatePath(Val("library")).decode("utf-8"))
def saveTorrent(self, torrentUrl): if not xbmcvfs.exists(torrentUrl) or re.match("^http.+$", torrentUrl): if re.match("^magnet\:.+$", torrentUrl): self.magnetLink = torrentUrl self.magnetToTorrent(torrentUrl) self.magnetLink = None return self.torrentFile else: if not xbmcvfs.exists(self.torrentFilesPath): xbmcvfs.mkdirs(self.torrentFilesPath) torrentFile = os.path.join(self.torrentFilesPath, self.md5(torrentUrl) + '.torrent') try: if not re.match("^http\:.+$", torrentUrl): content = xbmcvfs.File(torrentUrl, "rb").read() else: request = urllib2.Request(torrentUrl) request.add_header('Referer', torrentUrl) request.add_header('Accept-encoding', 'gzip') result = urllib2.urlopen(request) if result.info().get('Content-Encoding') == 'gzip': buf = StringIO(result.read()) f = gzip.GzipFile(fileobj=buf) content = f.read() else: content = result.read() localFile = xbmcvfs.File(torrentFile, "w+b") localFile.write(content) localFile.close() except Exception, e: print 'Unable to save torrent file from "' + torrentUrl + '" to "' + torrentFile + '" in Torrent::saveTorrent' + '. Exception: ' + str( e) return
def create(self): xbmcvfs.mkdirs(self.fullpath)
def getExtraFanArt(embyId, embyPath): emby = embyserver.Read_EmbyServer() art = artwork.Artwork() # Get extrafanart for listitem # will be called by skinhelper script to get the extrafanart try: # for tvshows we get the embyid just from the path if not embyId: if "plugin.video.emby" in embyPath: embyId = embyPath.split("/")[-2] if embyId: #only proceed if we actually have a emby id log("Requesting extrafanart for Id: %s" % embyId, 0) # We need to store the images locally for this to work # because of the caching system in xbmc fanartDir = xbmc.translatePath("special://thumbnails/emby/%s/" % embyId).decode('utf-8') if not xbmcvfs.exists(fanartDir): # Download the images to the cache directory xbmcvfs.mkdirs(fanartDir) item = emby.getItem(embyId) if item: backdrops = art.getAllArtwork(item)['Backdrop'] tags = item['BackdropImageTags'] count = 0 for backdrop in backdrops: # Same ordering as in artwork tag = tags[count] if os.path.supports_unicode_filenames: fanartFile = os.path.join(fanartDir, "fanart%s.jpg" % tag) else: fanartFile = os.path.join( fanartDir.encode("utf-8"), "fanart%s.jpg" % tag.encode("utf-8")) li = xbmcgui.ListItem(tag, path=fanartFile) xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=fanartFile, listitem=li) xbmcvfs.copy(backdrop, fanartFile) count += 1 else: log("Found cached backdrop.", 2) # Use existing cached images dirs, files = xbmcvfs.listdir(fanartDir) for file in files: fanartFile = os.path.join(fanartDir, file.decode('utf-8')) li = xbmcgui.ListItem(file, path=fanartFile) xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=fanartFile, listitem=li) except Exception as e: log("Error getting extrafanart: %s" % e, 0) # Always do endofdirectory to prevent errors in the logs xbmcplugin.endOfDirectory(int(sys.argv[1]))
def make_dir(self, mypath): ''' Creates sub-directories if they are not found. ''' try: if not xbmcvfs.exists(mypath): xbmcvfs.mkdirs(mypath) except: if not os.path.exists(mypath): os.makedirs(mypath)
def _init_filesystem_cache(self): from xbmcvfs import mkdirs from resources.lib.cache import BUCKET_NAMES for bucket in BUCKET_NAMES: mkdirs(xbmc.translatePath(os.path.join(self.CACHE_PATH, bucket)))
__addon__ = xbmcaddon.Addon() __author__ = __addon__.getAddonInfo('author') __scriptid__ = __addon__.getAddonInfo('id') __scriptname__ = __addon__.getAddonInfo('name') __version__ = __addon__.getAddonInfo('version') __language__ = __addon__.getLocalizedString __cwd__ = xbmc.translatePath(__addon__.getAddonInfo('path')).decode("utf-8") __profile__ = xbmc.translatePath(__addon__.getAddonInfo('profile')).decode("utf-8") __resource__ = xbmc.translatePath(os.path.join(__cwd__, 'resources', 'lib')).decode("utf-8") __temp__ = xbmc.translatePath(os.path.join(__profile__, 'temp', '')) if xbmcvfs.exists(__temp__): shutil.rmtree(__temp__) xbmcvfs.mkdirs(__temp__) sys.path.append (__resource__) from OSUtilities import OSDBServer, log, normalizeString import requests def Search(item): search_data = [] try: search_data = OSDBServer().searchsubtitles(item) except: log(__name__, "failed to connect to service for subtitle search") xbmc.executebuiltin((u'Notification(%s,%s)' % (__scriptname__, __language__(32001))).encode('utf-8')) return if search_data != None: for item_data in search_data:
from datetime import date, datetime, timedelta import hashlib import json import gzip import sys import re ADDON = xbmcaddon.Addon() logger = logging.getLogger(ADDON.getAddonInfo('id')) kodilogging.config() plugin = routing.Plugin() __profile__ = xbmc.translatePath(ADDON.getAddonInfo('profile')) if not xbmcvfs.exists(__profile__): xbmcvfs.mkdirs(__profile__) favorites_file_path = __profile__+"favorites.json" favorites = {} icon_path = ADDON.getAddonInfo('path')+"/resources/logos/{0}.png" setContent(plugin.handle, '') @plugin.route('/') def index(): icon = get_url(ids.collections_request_url.format(id=ids.icon_id, page="1")) live_icon = "" highlights_icon = "" highlights_id = ids.highlights_id mediathek_icon = ""
def download_media(url, path, file_name): try: progress = int(kodi.get_setting('down_progress')) request = urllib2.Request(url) request.add_header('User-Agent', USER_AGENT) request.add_unredirected_header('Host', request.get_host()) response = urllib2.urlopen(request) content_length = 0 if 'Content-Length' in response.info(): content_length = int(response.info()['Content-Length']) file_name = file_name.replace('.strm', get_extension(url, response)) full_path = os.path.join(path, file_name) log_utils.log('Downloading: %s -> %s' % (url, full_path), log_utils.LOGDEBUG) path = xbmc.makeLegalFilename(path) if not xbmcvfs.exists(path): try: try: xbmcvfs.mkdirs(path) except: os.mkdir(path) except Exception as e: raise Exception(i18n('failed_create_dir')) file_desc = xbmcvfs.File(full_path, 'w') total_len = 0 if progress: if progress == PROGRESS.WINDOW: dialog = xbmcgui.DialogProgress() else: dialog = xbmcgui.DialogProgressBG() dialog.create('Stream All The Sources', i18n('downloading') % (file_name)) dialog.update(0) while True: data = response.read(CHUNK_SIZE) if not data: break if progress == PROGRESS.WINDOW and dialog.iscanceled(): break total_len += len(data) if not file_desc.write(data): raise Exception('failed_write_file') percent_progress = (total_len) * 100 / content_length if content_length > 0 else 0 log_utils.log('Position : %s / %s = %s%%' % (total_len, content_length, percent_progress), log_utils.LOGDEBUG) if progress == PROGRESS.WINDOW: dialog.update(percent_progress) elif progress == PROGRESS.BACKGROUND: dialog.update(percent_progress, 'Stream All The Sources') else: kodi.notify(msg=i18n('download_complete') % (file_name), duration=5000) log_utils.log('Download Complete: %s -> %s' % (url, full_path), log_utils.LOGDEBUG) file_desc.close() if progress: dialog.close() except Exception as e: log_utils.log('Error (%s) during download: %s -> %s' % (str(e), url, file_name), log_utils.LOGERROR) kodi.notify(msg=i18n('download_error') % (str(e), file_name), duration=5000)
def main(): """Main entry point of the script when it is invoked by XBMC.""" global kodi_major_version # Get parameters from XBMC and launch actions params = get_params(sys.argv) action = params.get('action', 'Unknown') xbmc.log(u"SUBDIVX - Version: %s -- Action: %s" % (__version__, action), level=LOGNOTICE) kodi_major_version = int( xbmc.getInfoLabel('System.BuildVersion').split('.')[0]) if action in ('search', 'manualsearch'): item = { 'temp': False, 'rar': False, 'year': xbmc.getInfoLabel("VideoPlayer.Year"), 'season': str(xbmc.getInfoLabel("VideoPlayer.Season")), 'episode': str(xbmc.getInfoLabel("VideoPlayer.Episode")), 'tvshow': normalize_string(xbmc.getInfoLabel("VideoPlayer.TVshowtitle")), # Try to get original title 'title': normalize_string(xbmc.getInfoLabel("VideoPlayer.OriginalTitle")), # Full path of a playing file 'file_original_path': unquote(xbmc.Player().getPlayingFile().decode('utf-8')), '3let_language': [], '2let_language': [], 'manual_search': 'searchstring' in params, } if 'searchstring' in params: item['manual_search_string'] = params['searchstring'] for lang in unquote(params['languages']).decode('utf-8').split(","): item['3let_language'].append( xbmc.convertLanguage(lang, xbmc.ISO_639_2)) item['2let_language'].append( xbmc.convertLanguage(lang, xbmc.ISO_639_1)) if not item['title']: # No original title, get just Title item['title'] = normalize_string( xbmc.getInfoLabel("VideoPlayer.Title")) if "s" in item['episode'].lower(): # Check if season is "Special" item['season'] = "0" item['episode'] = item['episode'][-1:] if "http" in item['file_original_path']: item['temp'] = True elif "rar://" in item['file_original_path']: item['rar'] = True item['file_original_path'] = os.path.dirname( item['file_original_path'][6:]) elif "stack://" in item['file_original_path']: stackPath = item['file_original_path'].split(" , ") item['file_original_path'] = stackPath[0][8:] Search(item) # Send end of directory to XBMC xbmcplugin.endOfDirectory(int(sys.argv[1])) elif action == 'download': debug_dump_path( xbmc.translatePath(__addon__.getAddonInfo('profile')), "xbmc.translatePath(__addon__.getAddonInfo('profile'))") debug_dump_path(__profile__, '__profile__') xbmcvfs.mkdirs(__profile__) _cleanup_tempdirs(__profile__) workdir = tempfile.mkdtemp(dir=__profile__) # Make sure it ends with a path separator (Kodi 14) workdir = workdir + os.path.sep debug_dump_path(workdir, 'workdir') # We pickup our arguments sent from the Search() function subs = Download(params["id"], workdir) # We can return more than one subtitle for multi CD versions, for now # we are still working out how to handle that in XBMC core for sub in subs: # XXX: Kodi still can't handle multiple subtitles files returned # from an addon, it will always use the first file returned. So # there is no point in reporting a forced subtitle file to it. # See https://github.com/ramiro/service.subtitles.subdivx/issues/14 if sub['forced']: continue listitem = xbmcgui.ListItem(label=sub['path']) xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sub['path'], listitem=listitem, isFolder=False) # Send end of directory to XBMC xbmcplugin.endOfDirectory(int(sys.argv[1])) sleep(2) if __addon__.getSetting('show_nick_in_place_of_lang') == 'true': _double_dot_fix_hack(params['filename'].encode('utf-8')) _cleanup_tempdir(workdir, verbose=True)
#xbmc.log("base_url: " + str(base_url) + " mode: " + str(mode), xbmc.LOGINFO) if mode == constants.ADDALLTOLIBRARY: xbmc.log("Start of ADDALLTOLIBRARY, rootFolder=" + str(getRootFolder()), xbmc.LOGINFO) xbmc.executebuiltin( 'Notification(VDR Recordings, ' + xbmcaddon.Addon(constants.ADDON_NAME).getLocalizedString(30109) + ')', False) # create list of old files old_files = {} recursive_add_files(constants.LIBRARY_MOVIES, old_files) recursive_add_files(constants.LIBRARY_TV_SHOWS, old_files) recursive_add_files(constants.LIBRARY_MUSIC_VIDEOS, old_files) # make directories (if required) xbmcvfs.mkdirs(constants.LIBRARY_MOVIES) xbmcvfs.mkdirs(constants.LIBRARY_TV_SHOWS) xbmcvfs.mkdirs(constants.LIBRARY_MUSIC_VIDEOS) # add current (new) files new_files = {} xbmc.log("ADDALLTOLIBRARY, before adding all files", xbmc.LOGINFO) kfolder.kFolder(getRootFolder()).parseFolder(-10, new_files) xbmc.log("ADDALLTOLIBRARY, after adding all files", xbmc.LOGINFO) ## compare list of old files with list of new files, clean up library for files which do no longer exist for file in old_files.keys() - new_files.keys(): # files do no longer exist -> delete xbmcvfs.delete(file) file_base, ext = os.path.splitext(file) if ext != ".strm" and ext != ".nfo": xbmcvfs.delete(file_base + ".edl") # delete all empty directries recursive_delete_empty_dirs(constants.LIBRARY_MOVIES)
def download(link, episode=""): subtitle_list = [] exts = [".srt", ".sub", ".txt", ".smi", ".ssa", ".ass"] downloadlink_pattern = "...<a href=\"(.+?)\" rel=\"nofollow\" onclick=\"DownloadSubtitle" uid = uuid.uuid4() tempdir = os.path.join(TEMP, unicode(uid)) xbmcvfs.mkdirs(tempdir) content, response_url = geturl(link) match = re.compile(downloadlink_pattern).findall(content) if match: downloadlink = main_url + match[0] viewstate = 0 previouspage = 0 subtitleid = 0 typeid = "zip" filmid = 0 postparams = urllib.urlencode( {'__EVENTTARGET': 's$lc$bcr$downloadLink', '__EVENTARGUMENT': '', '__VIEWSTATE': viewstate, '__PREVIOUSPAGE': previouspage, 'subtitleId': subtitleid, 'typeId': typeid, 'filmId': filmid}) useragent = ("User-Agent=Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.3) " "Gecko/20100401 Firefox/3.6.3 ( .NET CLR 3.5.30729)") headers = {'User-Agent': useragent, 'Referer': link} log(__name__, "Fetching subtitles using url '%s' with referer header '%s' and post parameters '%s'" % ( downloadlink, link, postparams)) request = urllib2.Request(downloadlink, postparams, headers) response = urllib2.urlopen(request) if response.getcode() != 200: log(__name__, "Failed to download subtitle file") return subtitle_list local_tmp_file = os.path.join(tempdir, "subscene.xxx") packed = False try: log(__name__, "Saving subtitles to '%s'" % local_tmp_file) local_file_handle = xbmcvfs.File(local_tmp_file, "wb") local_file_handle.write(response.read()) local_file_handle.close() # Check archive type (rar/zip/else) through the file header (rar=Rar!, zip=PK) myfile = xbmcvfs.File(local_tmp_file, "rb") myfile.seek(0,0) if myfile.read(1) == 'R': typeid = "rar" packed = True log(__name__, "Discovered RAR Archive") else: myfile.seek(0,0) if myfile.read(1) == 'P': typeid = "zip" packed = True log(__name__, "Discovered ZIP Archive") else: typeid = "srt" packed = False log(__name__, "Discovered a non-archive file") myfile.close() local_tmp_file = os.path.join(tempdir, "subscene." + typeid) xbmcvfs.rename(os.path.join(tempdir, "subscene.xxx"), local_tmp_file) log(__name__, "Saving to %s" % local_tmp_file) except: log(__name__, "Failed to save subtitle to %s" % local_tmp_file) if packed: xbmc.sleep(500) xbmc.executebuiltin(('XBMC.Extract("%s","%s")' % (local_tmp_file, tempdir,)).encode('utf-8'), True) episode_pattern = None if episode != '': episode_pattern = re.compile(get_episode_pattern(episode), re.IGNORECASE) for dir in xbmcvfs.listdir(tempdir)[0]: for file in xbmcvfs.listdir(os.path.join(tempdir, dir))[1]: if os.path.splitext(file)[1] in exts: log(__name__, 'match '+episode+' '+file) if episode_pattern and not episode_pattern.search(file): continue log(__name__, "=== returning subtitle file %s" % file) subtitle_list.append(os.path.join(tempdir, dir, file)) for file in xbmcvfs.listdir(tempdir)[1]: if os.path.splitext(file)[1] in exts: log(__name__, 'match '+episode+' '+file) if episode_pattern and not episode_pattern.search(file): continue log(__name__, "=== returning subtitle file %s" % file) subtitle_list.append(os.path.join(tempdir, file)) if len(subtitle_list) == 0: if episode: _xbmc_notification(32002) else: _xbmc_notification(32003) return subtitle_list
def rmtree(path): if isinstance(path, unicode): path = path.encode('utf-8') dirs, files = xbmcvfs.listdir(path) for dir in dirs: rmtree(os.path.join(path, dir)) for file in files: xbmcvfs.delete(os.path.join(path, file)) xbmcvfs.rmdir(path) try: rmtree(TEMP) except: pass xbmcvfs.mkdirs(TEMP) def find_movie(content, title, year): found_urls = {} found_movies = [] h = HTMLParser.HTMLParser() for secmatches in re.finditer(search_section_pattern, content, re.IGNORECASE | re.DOTALL): log(__name__, secmatches.group('section')) for matches in re.finditer(movie_season_pattern, secmatches.group('content'), re.IGNORECASE | re.DOTALL): if matches.group('link') in found_urls: if secmatches.group('section') == 'close': found_movies[found_urls[matches.group('link')]]['is_close'] = True if secmatches.group('section') == 'exact': found_movies[found_urls[matches.group('link')]]['is_exact'] = True
if __name__ == "__main__": log("#############################################################", xbmc.LOGNOTICE) for credit in __cdam__.credits(): log("# %-55s #" % credit, xbmc.LOGNOTICE) log("#############################################################", xbmc.LOGNOTICE) log("Looking for settings.xml", xbmc.LOGNOTICE) if not xbmcvfs.exists(__cdam__.file_settings_xml() ): # Open Settings if settings.xml does not exists log("settings.xml File not found, creating path and opening settings", xbmc.LOGNOTICE) xbmcvfs.mkdirs(__cdam__.path_profile()) __cfg__.open() soft_exit = True cu.settings_to_log(__cdam__.file_settings_xml()) script_mode, provided_mbid, provided_dbid, media_type = get_script_mode() if xbmcgui.Window(10000).getProperty("cdart_manager_running") == "True": log("cdART Manager Already running, exiting...", xbmc.LOGNOTICE) soft_exit = True else: xbmcgui.Window(10000).setProperty("cdart_manager_running", "True") if not soft_exit: try: if __cfg__.enable_all_artists():
def backup(): ''' Jellyfin backup. ''' from helper.utils import delete_folder, copytree path = settings('backupPath') folder_name = "Kodi%s.%s" % (xbmc.getInfoLabel('System.BuildVersion')[:2], xbmc.getInfoLabel('System.Date(dd-mm-yy)')) folder_name = dialog("input", heading=_(33089), defaultt=folder_name) if not folder_name: return backup = os.path.join(path, folder_name) if xbmcvfs.exists(backup + '/'): if not dialog("yesno", heading="{jellyfin}", line1=_(33090)): return backup() delete_folder(backup) addon_data = xbmc.translatePath( "special://profile/addon_data/plugin.video.jellyfin").decode('utf-8') destination_data = os.path.join(backup, "addon_data", "plugin.video.jellyfin") destination_databases = os.path.join(backup, "Database") if not xbmcvfs.mkdirs(path) or not xbmcvfs.mkdirs(destination_databases): LOG.info("Unable to create all directories") dialog("notification", heading="{jellyfin}", icon="{jellyfin}", message=_(33165), sound=False) return copytree(addon_data, destination_data) databases = Objects().objects db = xbmc.translatePath(databases['jellyfin']).decode('utf-8') xbmcvfs.copy(db, os.path.join(destination_databases, db.rsplit('\\', 1)[1])) LOG.info("copied jellyfin.db") db = xbmc.translatePath(databases['video']).decode('utf-8') filename = db.rsplit('\\', 1)[1] xbmcvfs.copy(db, os.path.join(destination_databases, filename)) LOG.info("copied %s", filename) if settings('enableMusic.bool'): db = xbmc.translatePath(databases['music']).decode('utf-8') filename = db.rsplit('\\', 1)[1] xbmcvfs.copy(db, os.path.join(destination_databases, filename)) LOG.info("copied %s", filename) LOG.info("backup completed") dialog("ok", heading="{jellyfin}", line1="%s %s" % (_(33091), backup))
def Download(url, filename, pack, language): # standard input # Create some variables subtitles = [] random = uuid.uuid4().hex extractPath = os.path.join(__temp__, "Extracted") cleanDirectory(__temp__) if not xbmcvfs.exists(extractPath): xbmcvfs.mkdirs(extractPath) FileContent, FileExt = LTV.Download(url) fname = "%s.%s" % (os.path.join(__temp__, random), FileExt) with open(fname, 'wb') as f: f.write(FileContent) translated_archive_url = 'archive://%s' % urllib.quote_plus( xbmc.translatePath(fname)) extractedFileList, success = extractArchiveToFolder( translated_archive_url, extractPath) files = xbmc_walk(extractPath) temp = [] for file in files: sub = urllib.unquote_plus(file) sub, ext = os.path.splitext(os.path.basename(file)) sub_striped = LTV.CleanLTVTitle(sub) Ratio = LTV.CalculateRatio(sub_striped, LTV.CleanLTVTitle(filename)) temp.append([Ratio, file, sub, ext]) subtitles = sorted(temp, reverse=True) outputSub = [] if len(subtitles) > 1: if pack: subtitles.append(["pack", "pack", __language__(32010), ""]) dialog = xbmcgui.Dialog() sel = dialog.select( "%s\n%s" % (__language__(32001).encode("utf-8"), filename), [os.path.basename(b) for a, b, c, d in subtitles]) if sel >= 0: subSelected = subtitles[sel][1] # Handling package import if subtitles[sel][0] == "pack": dir = os.path.dirname( urllib.unquote( xbmc.Player().getPlayingFile().decode('utf-8'))) for f in xbmc_walk(dir): if os.path.splitext(f)[1] in [ ".mkv", ".avi", ".vob", ".mov", ".mp4" ]: for x, s in subtitles: se, fe = 0, 1 if re.search(r"s\d{2}e\d{2}", s.lower()): se = re.findall(r"s\d{2}e\d{2}", s.lower())[0] if re.search(r"s\d{2}e\d{2}", f.lower()): fe = re.findall(r"s\d{2}e\d{2}", f.lower())[0] if se == fe: if os.path.basename(f) == os.path.basename( filename): outputSub.append(s) name = os.path.splitext(f)[0] ext = os.path.splitext(s)[1] lang = "pt" if re.search( r"Portuguese", language) else "en" out = "%s.%s%s" % (name, lang, ext) xbmcvfs.copy(s, out) temp_sel = os.path.join(extractPath, "%s.%s" % (random, subtitles[sel][3])) xbmcvfs.copy(subSelected, temp_sel) outputSub.append(temp_sel) elif len(subtitles) == 1: subSelected = subtitles[0][1] temp_sel = os.path.join(extractPath, "%s.%s" % (random, subtitles[0][3])) xbmcvfs.copy(subSelected, temp_sel) outputSub.append(temp_sel) return outputSub
def __init__(self): self._parse_argv() # If there are no custom library nodes in the profile directory, copy them from the Kodi install targetDir = os.path.join( xbmc.translatePath( "special://profile".decode('utf-8') ), "library", ltype ) if True: if not os.path.exists( targetDir ): xbmcvfs.mkdirs( targetDir ) originDir = os.path.join( xbmc.translatePath( "special://xbmc".decode( "utf-8" ) ), "system", "library", ltype ) dirs, files = xbmcvfs.listdir( originDir ) self.copyNode( dirs, files, targetDir, originDir ) else: xbmcgui.Dialog().ok(ADDONNAME, LANGUAGE( 30400 ) ) print_exc xbmcplugin.endOfDirectory(handle=int(sys.argv[1])) return # Create data if not exists if not os.path.exists(DATAPATH): xbmcvfs.mkdir(DATAPATH) if "type" in self.PARAMS: # We're performing a specific action if self.PARAMS[ "type" ] == "delete": message = LANGUAGE( 30401 ) if self.PARAMS[ "actionPath" ] == targetDir: # Ask the user is they want to reset all nodes message = LANGUAGE( 30402 ) result = xbmcgui.Dialog().yesno(ADDONNAME, message ) if result: if self.PARAMS[ "actionPath" ].endswith( ".xml" ): # Delete single file xbmcvfs.delete( self.PARAMS[ "actionPath" ] ) else: # Delete folder RULE.deleteAllNodeRules( self.PARAMS[ "actionPath" ] ) shutil.rmtree( self.PARAMS[ "actionPath" ] ) else: return elif self.PARAMS[ "type" ] == "deletenode": result = xbmcgui.Dialog().yesno(ADDONNAME, LANGUAGE( 30403 ) ) if result: self.changeViewElement( self.PARAMS[ "actionPath" ], self.PARAMS[ "node" ], "" ) elif self.PARAMS[ "type" ] == "editlabel": if self.PARAMS[ "label" ].isdigit(): label = xbmc.getLocalizedString( int( self.PARAMS[ "label" ] ) ) else: label = self.PARAMS[ "label" ] # Get new label from keyboard dialog keyboard = xbmc.Keyboard( label, LANGUAGE( 30300 ), False ) keyboard.doModal() if ( keyboard.isConfirmed() ): newlabel = keyboard.getText().decode( "utf-8" ) if newlabel != "" and newlabel != label: # We've got a new label, update the xml file self.changeViewElement( self.PARAMS[ "actionPath" ], "label", newlabel ) else: return elif self.PARAMS[ "type" ] == "editvisibility": currentVisibility = self.getRootAttrib( self.PARAMS[ "actionPath" ], "visible" ) # Get new visibility from keyboard dialog keyboard = xbmc.Keyboard( currentVisibility, LANGUAGE( 30301 ), False ) keyboard.doModal() if ( keyboard.isConfirmed() ): newVisibility = keyboard.getText() if newVisibility != currentVisibility: # We've got a new label, update the xml file self.changeRootAttrib( self.PARAMS[ "actionPath" ], "visible", newVisibility ) else: return elif self.PARAMS[ "type" ] == "moveNode": self.indexCounter = -1 # Get existing nodes nodes = {} self.listNodes( self.PARAMS[ "actionPath" ], nodes ) # Get updated order newOrder = moveNodes.getNewOrder( nodes, int( self.PARAMS[ "actionItem" ] ) ) if newOrder is not None: # Update the orders for i, node in enumerate( newOrder, 1 ): path = urllib.unquote( node[ 2 ] ) if node[ 3 ] == "folder": path = os.path.join( urllib.unquote( node[ 2 ] ), "index.xml" ) self.changeRootAttrib( path, "order", str( i * 10 ) ) elif self.PARAMS[ "type" ] == "newView": # Get new view name from keyboard dialog keyboard = xbmc.Keyboard( "", LANGUAGE( 30316 ), False ) keyboard.doModal() if ( keyboard.isConfirmed() ): newView = keyboard.getText().decode( "utf-8" ) if newView != "": # Ensure filename is unique filename = self.slugify( newView.lower().replace( " ", "" ) ) if os.path.exists( os.path.join( self.PARAMS[ "actionPath" ], filename + ".xml" ) ): count = 0 while os.path.exists( os.path.join( self.PARAMS[ "actionPath" ], filename + "-" + str( count ) + ".xml" ) ): count += 1 filename = filename + "-" + str( count ) # Create a new xml file tree = xmltree.ElementTree( xmltree.Element( "node" ) ) root = tree.getroot() subtree = xmltree.SubElement( root, "label" ).text = newView # Add any node rules RULE.addAllNodeRules( self.PARAMS[ "actionPath" ], root ) # Write the xml file self.indent( root ) tree.write( os.path.join( self.PARAMS[ "actionPath" ], filename + ".xml" ), encoding="UTF-8" ) else: return elif self.PARAMS[ "type" ] == "newNode": # Get new node name from the keyboard dialog keyboard = xbmc.Keyboard( "", LANGUAGE( 30303 ), False ) keyboard.doModal() if ( keyboard.isConfirmed() ): newNode = keyboard.getText().decode( "utf8" ) if newNode == "": return # Ensure foldername is unique foldername = self.slugify( newNode.lower().replace( " ", "" ) ) if os.path.exists( os.path.join( self.PARAMS[ "actionPath" ], foldername + os.pathsep ) ): count = 0 while os.path.exists( os.path.join( self.PARAMS[ "actionPath" ], foldername + "-" + str( count ) + os.pathsep ) ): count += 1 foldername = foldername + "-" + str( count ) foldername = os.path.join( self.PARAMS[ "actionPath" ], foldername ) # Create new node folder xbmcvfs.mkdir( foldername ) # Create a new xml file tree = xmltree.ElementTree( xmltree.Element( "node" ) ) root = tree.getroot() subtree = xmltree.SubElement( root, "label" ).text = newNode # Ask user if they want to import defaults if ltype.startswith( "video" ): defaultNames = [ xbmc.getLocalizedString( 231 ), xbmc.getLocalizedString( 342 ), xbmc.getLocalizedString( 20343 ), xbmc.getLocalizedString( 20389 ) ] defaultValues = [ "", "movies", "tvshows", "musicvideos" ] selected = xbmcgui.Dialog().select( LANGUAGE( 30304 ), defaultNames ) else: selected = 0 # If the user selected some defaults... if selected != -1 and selected != 0: try: # Copy those defaults across originDir = os.path.join( xbmc.translatePath( "special://xbmc".decode( "utf-8" ) ), "system", "library", ltype, defaultValues[ selected ] ) dirs, files = xbmcvfs.listdir( originDir ) for file in files: if file != "index.xml": xbmcvfs.copy( os.path.join( originDir, file), os.path.join( foldername, file ) ) # Open index.xml and copy values across index = xmltree.parse( os.path.join( originDir, "index.xml" ) ).getroot() if "visible" in index.attrib: root.set( "visible", index.attrib.get( "visible" ) ) icon = index.find( "icon" ) if icon is not None: xmltree.SubElement( root, "icon" ).text = icon.text except: print_exc() # Write the xml file self.indent( root ) tree.write( os.path.join( foldername, "index.xml" ), encoding="UTF-8" ) else: return elif self.PARAMS[ "type" ] == "rule": # Display list of all elements of a rule RULE.displayRule( self.PARAMS[ "actionPath" ], self.PATH, self.PARAMS[ "rule" ] ) return elif self.PARAMS[ "type" ] == "editMatch": # Editing the field the rule is matched against RULE.editMatch( self.PARAMS[ "actionPath" ], self.PARAMS[ "rule" ], self.PARAMS[ "content"], self.PARAMS[ "default" ] ) elif self.PARAMS[ "type" ] == "editOperator": # Editing the operator of a rule RULE.editOperator( self.PARAMS[ "actionPath" ], self.PARAMS[ "rule" ], self.PARAMS[ "group" ], self.PARAMS[ "default" ] ) elif self.PARAMS[ "type" ] == "editValue": # Editing the value of a rule RULE.editValue( self.PARAMS[ "actionPath" ], self.PARAMS[ "rule" ] ) elif self.PARAMS[ "type" ] == "browseValue": # Browse for the new value of a rule RULE.browse( self.PARAMS[ "actionPath" ], self.PARAMS[ "rule" ], self.PARAMS[ "match" ], self.PARAMS[ "content" ] ) elif self.PARAMS[ "type" ] == "deleteRule": # Delete a rule RULE.deleteRule( self.PARAMS[ "actionPath" ], self.PARAMS[ "rule" ] ) elif self.PARAMS[ "type" ] == "editRulesMatch": # Editing whether any or all rules must match ATTRIB.editMatch( self.PARAMS[ "actionPath" ] ) # --- Edit order-by --- elif self.PARAMS[ "type" ] == "orderby": # Display all elements of order by ORDERBY.displayOrderBy( self.PARAMS[ "actionPath" ] ) return elif self.PARAMS[ "type" ] == "editOrderBy": ORDERBY.editOrderBy( self.PARAMS[ "actionPath" ], self.PARAMS[ "content" ], self.PARAMS[ "default" ] ) elif self.PARAMS[ "type" ] == "editOrderByDirection": ORDERBY.editDirection( self.PARAMS[ "actionPath" ], self.PARAMS[ "default" ] ) # --- Edit paths --- elif self.PARAMS[ "type" ] == "addPath": ATTRIB.addPath( self.PARAMS[ "actionPath" ] ) elif self.PARAMS[ "type" ] == "editPath": ATTRIB.editPath( self.PARAMS[ "actionPath" ], self.PARAMS[ "value" ] ) elif self.PARAMS[ "type" ] == "pathRule": PATHRULE.displayRule( self.PARAMS[ "actionPath" ], int( self.PARAMS[ "rule" ] ) ) return elif self.PARAMS[ "type" ] == "deletePathRule": ATTRIB.deletePathRule( self.PARAMS[ "actionPath" ], int( self.PARAMS[ "rule" ] ) ) elif self.PARAMS[ "type" ] == "editPathMatch": # Editing the field the rule is matched against PATHRULE.editMatch( self.PARAMS[ "actionPath" ], int( self.PARAMS[ "rule" ] ) ) elif self.PARAMS[ "type" ] == "editPathValue": # Editing the value of a rule PATHRULE.editValue( self.PARAMS[ "actionPath" ], int( self.PARAMS[ "rule" ] ) ) elif self.PARAMS[ "type" ] == "browsePathValue": # Browse for the new value of a rule PATHRULE.browse( self.PARAMS[ "actionPath" ], int( self.PARAMS[ "rule" ] ) ) # --- Edit other attribute of view --- # > Content elif self.PARAMS[ "type" ] == "editContent": ATTRIB.editContent( self.PARAMS[ "actionPath" ], "" ) # No default to pass, yet! # > Grouping elif self.PARAMS[ "type" ] == "editGroup": ATTRIB.editGroup( self.PARAMS[ "actionPath" ], self.PARAMS[ "content" ], "" ) # > Limit elif self.PARAMS[ "type" ] == "editLimit": ATTRIB.editLimit( self.PARAMS[ "actionPath" ], self.PARAMS[ "value" ] ) # > Icon (also for node) elif self.PARAMS[ "type" ] == "editIcon": ATTRIB.editIcon( self.PARAMS[ "actionPath" ], self.PARAMS[ "value" ] ) elif self.PARAMS[ "type" ] == "browseIcon": ATTRIB.browseIcon( self.PARAMS[ "actionPath" ] ) # Refresh the listings and exit xbmc.executebuiltin("Container.Refresh") return if self.PATH.endswith( ".xml" ): self.RulesList() else: self.NodesList(targetDir)
def _create_db_path(self): if not xbmcvfs.exists(os.path.dirname(self.path)): xbmcvfs.mkdirs(os.path.dirname(self.path))
def makedirs(path): xbmcvfs.mkdirs(path)
def addRecordingToLibrary(self, libraryPath, filename, current_files, isMovie, nfoUrl): if len(self.getTsFiles()) == 0: return self.updateComskip() xbmcvfs.mkdirs(libraryPath) # can we use symlinks? (Otherwisae, edl / comskip does not work) use_symlinks = sys.platform.startswith( 'linux') and self.getTsFiles()[0].startswith('/') use_symlinks = use_symlinks and (isMovie or len(self.getTsFiles()) == 1) # extension of the new file / new symbolic link (.ts or .vdr or .strm) ext = os.path.splitext(self.getTsFiles()[0])[1] if not use_symlinks: ext = ".strm" # basename of the new file / new symbolic link sanTitle = re.sub(r'[/\\?%*:|"<>]', '-', filename) base_name = os.path.join(libraryPath, sanTitle) # create a unique basename, in case of duplicates i = 1 strmFileName = base_name + ext strmFileNameA = base_name + " part1" + ext while strmFileName in current_files or strmFileNameA in current_files: i = i + 1 strmFileName = base_name + str(i) + ext strmFileNameA = base_name + str(i) + " part1" + ext if i > 1: base_name = base_name + str(i) # create nfo file if nfoUrl != "": if isMovie: nfoFileName = base_name + ".nfo" else: nfoFileName = os.path.join(libraryPath, "tvshow.nfo") xbmcvfs.delete(nfoFileName) current_files[nfoFileName] = True with xbmcvfs.File(nfoFileName, "w") as f_nfo: try: f_nfo.write(nfoUrl) except: xbmc.log("Cannot open for write: " + str(nfoFileName), xbmc.LOGERROR) if use_symlinks: # create the symlinks stack_number = "" i = 1 for tsFile in self.getTsFiles(): if len(self.getTsFiles()) > 1: stack_number = " part" + str(i) i = i + 1 strmFileName = base_name + stack_number + ext edlFileName = base_name + stack_number + ".edl" xbmcvfs.delete(strmFileName) xbmcvfs.delete(edlFileName) try: os.symlink(tsFile, strmFileName) os.symlink( os.path.splitext(tsFile)[0] + ".edl", edlFileName) except: xbmc.log("Cannot create symlink: " + str(strmFileName), xbmc.LOGERROR) return -1 try: os.utime(strmFileName, times=(datetime.datetime.now().timestamp(), self.RecordingTime.timestamp())) except: xbmc.log( "Cannot update time of symlink: " + str(strmFileName), xbmc.LOGERROR) current_files[strmFileName] = True else: # symlinks are not supported, use strm file strmFileName = base_name + ".strm" xbmcvfs.delete(strmFileName) with xbmcvfs.File(strmFileName, "w") as f_strm: try: plu = constants.BASE_URL + '?' + urllib.parse.urlencode( { 'mode': 'play', 'recordingFolder': self.path }) f_strm.write(plu) ## use the plugin to play files with multiple *.ts files. Putting all these ts files in an strm file is broken for too many ts files # f_strm.write(self.getStackUrl()) except: xbmc.log("Cannot open for write: " + str(strmFileName), xbmc.LOGERROR) return -1 try: os.utime(strmFileName, times=(datetime.datetime.now().timestamp(), self.RecordingTime.timestamp())) except: xbmc.log( "Cannot update time of strm file: " + str(strmFileName), xbmc.LOGERROR) current_files[strmFileName] = True
if not os.path.exists(ADDONS): os.makedirs(ADDONS) newpath = xbmc.translatePath( os.path.join('special://home/addons/', ADDONID)) if os.path.exists(newpath): wiz.log("Folder already exists, cleaning House", xbmc.LOGNOTICE) wiz.cleanHouse(newpath) wiz.removeFolder(newpath) try: wiz.copytree(ADDONPATH, newpath) except Exception, e: pass wiz.forceUpdate(True) try: mybuilds = xbmc.translatePath(MYBUILDS) if not os.path.exists(mybuilds): xbmcvfs.mkdirs(mybuilds) except: pass wiz.log("[Auto Install Repo] Started", xbmc.LOGNOTICE) if AUTOINSTALL == 'Yes' and not os.path.exists(os.path.join(ADDONS, REPOID)): workingxml = wiz.workingURL(REPOADDONXML) if workingxml == True: ver = wiz.parseDOM(wiz.openURL(REPOADDONXML), 'addon', ret='version', attrs={'id': REPOID}) if len(ver) > 0: installzip = '%s-%s.zip' % (REPOID, ver[0]) workingrepo = wiz.workingURL(REPOZIPURL + installzip) if workingrepo == True:
class MyMonitor(xbmc.Monitor): def __init__(self, *args, **kwargs): xbmc.Monitor.__init__(self) def onSettingsChanged(self): writeconfig() # addon __addon__ = xbmcaddon.Addon(id='service.net-snmp') __addonpath__ = xbmc.translatePath(__addon__.getAddonInfo('path')) __addonhome__ = xbmc.translatePath(__addon__.getAddonInfo('profile')) if not xbmcvfs.exists(xbmc.translatePath(__addonhome__ + 'share/snmp/')): xbmcvfs.mkdirs(xbmc.translatePath(__addonhome__ + 'share/snmp/')) config = xbmc.translatePath(__addonhome__ + 'share/snmp/snmpd.conf') persistent = xbmc.translatePath(__addonhome__ + 'snmpd.conf') def writeconfig(): system("systemctl stop service.net-snmp.service") community = __addon__.getSetting("COMMUNITY") location = __addon__.getSetting("LOCATION") contact = __addon__.getSetting("CONTACT") snmpversion = __addon__.getSetting("SNMPVERSION") cputemp = __addon__.getSetting("CPUTEMP") gputemp = __addon__.getSetting("GPUTEMP") if xbmcvfs.exists(persistent): xbmcvfs.delete(persistent)
dataPath, 'my_TLC_favourites.txt').encode('utf-8').decode('utf-8') defaultFanart = os.path.join(addonPath, 'fanart.jpg') icon = os.path.join(addonPath, 'icon.png') spPIC = os.path.join(addonPath, 'resources', 'media', '').encode('utf-8').decode('utf-8') useThumbAsFanart = addon.getSetting("useThumbAsFanart") == "true" enableAdjustment = addon.getSetting("show_settings") == "true" enableInputstream = addon.getSetting("inputstream") == "true" baseURL = "https://www.tlc.de/" xbmcplugin.setContent(int(sys.argv[1]), 'tvshows') if xbmcvfs.exists(temp) and os.path.isdir(temp): shutil.rmtree(temp, ignore_errors=True) xbmc.sleep(500) xbmcvfs.mkdirs(temp) cookie = os.path.join(temp, 'cookie.lwp') cj = LWPCookieJar() if xbmcvfs.exists(cookie): cj.load(cookie, ignore_discard=True, ignore_expires=True) def py2_enc(s, encoding='utf-8'): if PY2: if not isinstance(s, basestring): s = str(s) s = s.encode(encoding) if isinstance(s, unicode) else s return s
def download_media(url, path, file_name, translations, progress=None): try: if progress is None: progress = int(kodi.get_setting('down_progress')) i18n = translations.i18n active = not progress == PROGRESS.OFF background = progress == PROGRESS.BACKGROUND with kodi.ProgressDialog(kodi.get_name(), i18n('downloading') % (file_name), background=background, active=active) as pd: try: headers = dict([ item.split('=') for item in (url.split('|')[1]).split('&') ]) for key in headers: headers[key] = urllib.unquote(headers[key]) except: headers = {} if 'User-Agent' not in headers: headers['User-Agent'] = BROWSER_UA request = urllib2.Request(url.split('|')[0], headers=headers) response = urllib2.urlopen(request) if 'Content-Length' in response.info(): content_length = int(response.info()['Content-Length']) else: content_length = 0 file_name += '.' + get_extension(url, response) full_path = os.path.join(path, file_name) logger.log('Downloading: %s -> %s' % (url, full_path), log_utils.LOGDEBUG) path = kodi.translate_path(xbmc.makeLegalFilename(path)) try: try: xbmcvfs.mkdirs(path) except: os.makedirs(path) except Exception as e: logger.log('Path Create Failed: %s (%s)' % (e, path), log_utils.LOGDEBUG) if not path.endswith(os.sep): path += os.sep if not xbmcvfs.exists(path): raise Exception(i18n('failed_create_dir')) file_desc = xbmcvfs.File(full_path, 'w') total_len = 0 cancel = False while True: data = response.read(CHUNK_SIZE) if not data: break if pd.is_canceled(): cancel = True break total_len += len(data) if not file_desc.write(data): raise Exception(i18n('failed_write_file')) percent_progress = ( total_len ) * 100 / content_length if content_length > 0 else 0 logger.log( 'Position : %s / %s = %s%%' % (total_len, content_length, percent_progress), log_utils.LOGDEBUG) pd.update(percent_progress) file_desc.close() if not cancel: kodi.notify(msg=i18n('download_complete') % (file_name), duration=5000) logger.log('Download Complete: %s -> %s' % (url, full_path), log_utils.LOGDEBUG) except Exception as e: logger.log( 'Error (%s) during download: %s -> %s' % (str(e), url, file_name), log_utils.LOGERROR) kodi.notify(msg=i18n('download_error') % (str(e), file_name), duration=5000)
def make_list(imdb_ids, order, list_type, export): if export == "True": xbmcvfs.mkdirs( 'special://profile/addon_data/plugin.video.imdb.watchlists/Movies') xbmcvfs.mkdirs( 'special://profile/addon_data/plugin.video.imdb.watchlists/TV') items = [] for imdb_id in order: if plugin.get_setting( 'hide_duplicates') == "true" and existInKodiLibrary(imdb_id): continue imdb_data = imdb_ids[imdb_id] title = imdb_data['title'] year = imdb_data['year'] type = imdb_data['type'] plot = imdb_data['plot'] cast = imdb_data['cast'] thumbnail = imdb_data['thumbnail'] rating = imdb_data['rating'] votes = imdb_data['votes'] genres = imdb_data['genres'] certificate = imdb_data['certificate'] runtime = imdb_data['runtime'] meta_url = '' if type == "series": #TODO episode trakt_type = 'shows' meta_url = "plugin://plugin.video.imdb.watchlists/meta_tvdb/%s/%s" % ( imdb_id, urllib.quote_plus(title.encode("utf8"))) elif type == "featureFilm": trakt_type = 'movies' meta_url = 'plugin://%s/movies/play/imdb/%s/library' % ( plugin.get_setting('catchup.plugin').lower(), imdb_id) context_items = [] try: if xbmcaddon.Addon('plugin.program.super.favourites'): context_items.append(( 'iSearch', 'ActivateWindow(%d,"plugin://%s/?mode=%d&keyword=%s",return)' % (10025, 'plugin.program.super.favourites', 0, urllib.quote_plus(title.encode("utf8"))))) except: pass context_items.append( ('Add to Library', 'XBMC.RunPlugin(%s)' % (plugin.url_for('add_to_library', imdb_id=imdb_id, type=type, title=urllib.quote_plus(title.encode("utf8")), year=year)))) context_items.append( ('Delete from Library', 'XBMC.RunPlugin(%s)' % (plugin.url_for( 'delete_from_library', imdb_id=imdb_id, type=type)))) context_items.append(('Add to Trakt Watchlist', 'XBMC.RunPlugin(%s)' % (plugin.url_for('add_to_trakt_watchlist', type=trakt_type, imdb_id=imdb_id, title=title.encode("utf8"))))) context_items.append(('Add to Trakt Collection', 'XBMC.RunPlugin(%s)' % (plugin.url_for('add_to_trakt_collection', type=trakt_type, imdb_id=imdb_id, title=title.encode("utf8"))))) try: if type == 'featureFilm' and xbmcaddon.Addon( 'plugin.video.couchpotato_manager'): context_items.append(( 'Add to Couch Potato', "XBMC.RunPlugin(plugin://plugin.video.couchpotato_manager/movies/add-by-id/%s)" % (imdb_id))) except: pass try: if type == 'series' and xbmcaddon.Addon('plugin.video.sickrage'): context_items.append(( 'Add to Sickrage', "XBMC.RunPlugin(plugin://plugin.video.sickrage?action=addshow&&show_name=%s)" % (urllib.quote_plus(title.encode("utf8"))))) except: pass item = { 'label': title, 'path': meta_url, 'thumbnail': thumbnail, 'info': { 'title': title, 'genre': ','.join(genres), 'code': imdb_id, 'year': year, 'rating': rating, 'plot': plot, 'mpaa': certificate, 'cast': cast, 'duration': runtime, 'votes': votes }, 'context_menu': context_items, 'replace_context_menu': False, } if list_type == "tv": if type == "series": #TODO episode items.append(item) elif list_type == "movies": if type == "featureFilm": items.append(item) else: items.append(item) if export == "True": add_to_library(imdb_id, type, title, year) plugin.set_content('movies') plugin.add_sort_method(xbmcplugin.SORT_METHOD_UNSORTED) plugin.add_sort_method(xbmcplugin.SORT_METHOD_TITLE) return items
def __create_folder(self, basepath, folder): new_folder = os.path.join(basepath, folder) if not xbmcvfs.exists(new_folder): xbmcvfs.mkdirs(new_folder)
import os # import tempfile from ..compat import is_win32, is_py3 import xbmc, xbmcvfs xdg_cache = tmp_dir = xbmc.translatePath('special://profile/addon_data/script.module.streamlink.base') if not xbmcvfs.exists(tmp_dir): xbmcvfs.mkdirs(tmp_dir) if is_win32: try: from ctypes import windll, cast, c_ulong, c_void_p, byref except MemoryError: pass PIPE_ACCESS_OUTBOUND = 0x00000002 PIPE_TYPE_BYTE = 0x00000000 PIPE_READMODE_BYTE = 0x00000000 PIPE_WAIT = 0x00000000 PIPE_UNLIMITED_INSTANCES = 255 INVALID_HANDLE_VALUE = -1 class NamedPipe(object): def __init__(self, name): self.fifo = None
displayADDON.getAddonInfo('path')).encode('utf-8').decode('utf-8') displayA_Profile = xbmc.translatePath( displayADDON.getAddonInfo('profile')).encode('utf-8').decode('utf-8') displayA_Temp = xbmc.translatePath(os.path.join( displayA_Profile, 'temp', '')).encode('utf-8').decode('utf-8') background = os.path.join(displayA_Path, "bg.png") #wid = xbmcgui.getCurrentWindowId() #window=xbmcgui.Window(wid) #window.show() wait_time = 160 # 180 seconds = 3 minutes - wait at KODI start #loop_time = 60 # 60 seconds = 1 minute - time when the process started again if not xbmcvfs.exists(displayA_Temp): xbmcvfs.mkdirs(displayA_Temp) def py2_enc(s, encoding='utf-8'): if PY2 and isinstance(s, unicode): s = s.encode(encoding) return s def py2_uni(s, encoding='utf-8'): if PY2 and isinstance(s, str): s = unicode(s, encoding) return s def translation(id):
def __create_sqlite_db(self): if not xbmcvfs.exists(os.path.dirname(self.db_path)): try: xbmcvfs.mkdirs(os.path.dirname(self.db_path)) except: os.mkdir(os.path.dirname(self.db_path))
def makepath(path): if xbmcvfs.exists(path): return xbmc.translatePath(path) xbmcvfs.mkdirs(path) return xbmc.translatePath(path)
def create_dir(dirname): if not xbmcvfs.exists(dirname): xbmcvfs.mkdirs(dirname)
def Download(url): if not xbmcvfs.exists(__temp__.replace('\\', '/')): xbmcvfs.mkdirs(__temp__) dirs, files = xbmcvfs.listdir(__temp__) for file in files: xbmcvfs.delete(os.path.join(__temp__, file.decode("utf-8"))) subtitle_list = [] try: #data = GetHttpData(url) if re.match('https://', url) == None: if re.match('http://', url) != None: url = 'https://' + url[7:] else: dialog = xbmcgui.Dialog() ok = dialog.ok('错误提示', '非法url') ifbangumiurl = re.match('https://www.bilibili.com/bangumi/play/ss', url) ifvideourl = re.match('https://www.bilibili.com/video/', url) if ifbangumiurl or ifvideourl != None: if ifbangumiurl != None: ssid = re.search(r'ss[0-9]+', url) ssid = ssid.group() ssid = ssid[2:] r = GetHttpData( 'http://api.bilibili.com/pgc/web/season/section?season_id=' + ssid) j = json.loads(r) titles = [] cids = [] for p in range(len(j['result']['main_section']['episodes'])): titles.append( u'正片 - ' + j['result']['main_section']['episodes'][p]['title']) cids.append( j['result']['main_section']['episodes'][p]['cid']) for index in range(len(j['result']['section'])): duopname = j['result']['section'][index]['title'] for i in range( len(j['result']['section'][index]['episodes'])): titles.append(duopname + u' - ' + j['result']['section'][index]['episodes'] [i]['title']) cids.append(j['result']['section'][index]['episodes'] [i]['cid']) if ifvideourl != None: bvid = '' aid = '' if re.search(r'[Bb]{1}[Vv]{1}[a-zA-Z0-9]+', url): bvid = re.search(r'[Bb]{1}[Vv]{1}[a-zA-Z0-9]+', url) bvid = bvid.group() vurl = 'https://api.bilibili.com/x/web-interface/view?bvid=' + bvid if re.search('[aA]{1}[vV]{1}[0-9]+', url): aid = re.search(r'[aA]{1}[vV]{1}[0-9]+', url) aid = aid.group() aid = aid[2:] vurl = 'https://api.bilibili.com/x/web-interface/view?aid=' + aid r = GetHttpData(vurl) j = json.loads(r) #bvid = j['data']['pages'][0]['bvid'] titles = [] cids = [] for p in range(len(j['data']['pages'])): titles.append(j['data']['pages'][p]['part']) cids.append(j['data']['pages'][p]['cid']) if len(titles) > 1: sel = xbmcgui.Dialog().select('请选择分集的弹幕', titles) if sel == -1: sel = 0 else: sel = 0 r = requests.get('https://api.bilibili.com/x/v1/dm/list.so?oid=' + str(cids[sel])) r.encoding = 'utf-8' data = r.text pDialog = xbmcgui.DialogProgress() pDialog.create('获取弹幕', '初始化...') pDialog.update(50, '获取弹幕成功...') # dialog = xbmcgui.Dialog() # dialog.textviewer('错误提示', str(data.encode('utf-8'))) except: return [] if len(data) < 1024: return [] tmpfile = os.path.join( __temp__, "cid%s%s.ass" % (str(cids[sel]), os.path.splitext(url)[1])).replace( '\\', '/') # dialog = xbmcgui.Dialog() # dialog.textviewer('错误提示', str(tmpfile)) with open(tmpfile, "wb") as subFile: subFile.write(data.encode('utf-8')) pDialog.update(75, '写入xml成功...') xbmc.sleep(500) xml2ass.Danmaku2ASS(tmpfile, tmpfile, 960, 540, duration_marquee=10.0) pDialog.update(100, '转换ass成功...') pDialog.close() subtitle_list.append(tmpfile) return subtitle_list