Esempio n. 1
0
def showList(url,name):
		newShow(url)
		url=url+'/episodes'
		req = urllib2.Request(url)
		req.add_header('User-Agent', HEADER)
		f=urllib2.urlopen(req)
		a=f.read()
		f.close()
		p=re.compile('<!-- <span class="label">Page: </span> -->(.+?)<!-- <span class="label">Page: </span> -->', re.DOTALL)
		match=p.findall(a)
		o=re.compile('<a class="thumbnail" href="(.+?)"><img class="thumbnail" src="(.+?)"')
		data=o.findall(match[0])
		q=re.compile('Episode (.+?)<br />  (.+?)</a></p>')
		data2=q.findall(match[0])
		x=1
		y=0
		for url, thumb in data:
			url='http://revision3.com'+url
			print url
			name = 'Episode ' + data2[y][0] + ': ' + data2[y][1]
			name = str(int(x))+'. '+name
			li=xbmcgui.ListItem(name, iconImage=thumb, thumbnailImage=thumb)
			li.setInfo( type="Video", infoLabels={ "Title": name } )
			u=sys.argv[0]+"?mode=2&name="+urllib.quote_plus(name)+"&url="+urllib.quote_plus(url)
			xbmcplugin.addDirectoryItem(int(sys.argv[1]),u,li)
			#uncomment below to limit the amount of eps per show to 25
			# if (x == 24):
				# break
			x=x+1
			y=y+1
Esempio n. 2
0
def l111111l_SBK_(name,url,mode,iconimage,season):
    u=sys.argv[0]+l1l111_SBK_ (u"ࠤࡂࡹࡷࡲ࠽ࠣ৽")+urllib.quote_plus(url)+l1l111_SBK_ (u"ࠥࠪࡲࡵࡤࡦ࠿ࠥ৾")+str(mode)+l1l111_SBK_ (u"ࠦࠫࡴࡡ࡮ࡧࡀࠦ৿")+urllib.quote_plus(name)+l1l111_SBK_ (u"ࠧࠬࡳࡦࡣࡶࡳࡳࡃࠢ਀")+str(season)
    xbmcplugin.setContent(int(sys.argv[1]), l1l111_SBK_ (u"࠭ࡍࡰࡸ࡬ࡩࡸ࠭ਁ"))
    l11lll1l1_SBK_=xbmcgui.ListItem(name, iconImage=l1l111_SBK_ (u"ࠢࡧࡣࡱࡥࡷࡺ࠮࡫ࡲࡪࠦਂ"), thumbnailImage=iconimage)
    l11lll1l1_SBK_.setProperty(l1l111_SBK_ (u"ࠨࡨࡤࡲࡦࡸࡴࡠ࡫ࡰࡥ࡬࡫ࠧਃ"), __FANART__)
    xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=l11lll1l1_SBK_,isFolder=True)
    return True
Esempio n. 3
0
    def getCategoryItems(self, url, page):
        print "*** Get category items %s" % url
        page_url = "%s/page/%s/" % (url, str(int(page)))
        response = common.fetchPage({"link": page_url})
        items = 0

        if response["status"] == 200:
            content = common.parseDOM(response["content"], "div", attrs={"id": "page_content"})
            movie = common.parseDOM(content, "div", attrs={"class": "movie_teaser clearfix"})

            header = common.parseDOM(movie, "h2")
            links = common.parseDOM(header, "a", ret="href")
            titles = common.parseDOM(header, "a")

            poster = common.parseDOM(movie, "li", attrs={"class": "movie_teaser_poster"})
            images = common.parseDOM(poster, "img", ret="src")

            teaser = common.parseDOM(movie, "div", attrs={"class": "teaser_info"})
            descs = common.parseDOM(teaser, "div", attrs={"class": "teaser_desc"})

            infos = common.parseDOM(teaser, "ul", attrs={"class": "teaser_ads"})

            ratings = common.parseDOM(movie, "li", attrs={"class": "current-rating"})
            pagenav = common.parseDOM(response["content"], "div", attrs={"id": "pagenav"})

            for i, title in enumerate(titles):
                items += 1
                info = common.parseDOM(infos[i], "li")

                image = images[i]
                genre = self.encode(', '.join(common.parseDOM(info[2], "a")))
                year = info[1].split('</span>')[-1]
                desc = common.stripTags(self.encode(descs[i]))
                rating = int(ratings[i])/10 if ratings[i] > 0 else None

                try:
                    tmp = year.split(' ')
                    year = tmp[0]
                    season = tmp[1]+tmp[2]
                    title = "%s %s %s" % (self.encode(title), self.encode(season), year)

                except IndexError:
                    title = "%s (%s)" % (self.encode(title), year)

                uri = sys.argv[0] + '?mode=show&url=%s' % (links[i])
                item = xbmcgui.ListItem(title, iconImage=self.icon, thumbnailImage=self.url+image)
                item.setInfo(type='Video', infoLabels={'title': title, 'genre': genre, 'plot': desc, 'rating': rating})

                xbmcplugin.addDirectoryItem(self.handle, uri, item, True)

        else:
            self.showErrorMessage("getCategoryItems(): Bad response status%s" % response["status"])

        if pagenav and not items < 10:
            uri = sys.argv[0] + '?mode=%s&url=%s&page=%s' % ("category", url, str(int(page) + 1))
            item = xbmcgui.ListItem("Next page >>", thumbnailImage=self.inext)
            xbmcplugin.addDirectoryItem(self.handle, uri, item, True)

        xbmc.executebuiltin('Container.SetViewMode(52)')
        xbmcplugin.endOfDirectory(self.handle, True)
Esempio n. 4
0
def showListA(url,name):
		cat=name
		print url
		req = urllib2.Request(url)
		req.add_header('User-Agent', HEADER)
		f=urllib2.urlopen(req)
		a=f.read()
		f.close()
		p=re.compile('<item>(.+?)<title>(.+?) - ', re.DOTALL)
		o=re.compile('<enclosure url="(.+?)"')
		q=re.compile('</media:description>\n        (<media:thumbnail url="(.+?)" width="100" height="100" />\n        )?<media:player url', re.DOTALL)
		r=re.compile('<guid isPermaLink="false">(.+?)</guid>')
		info=re.compile('<content:encoded>\n(.+?)\n      </content:encoded>', re.DOTALL).findall(a)
		print info
		time=r.findall(a)
		match=p.findall(a)
		URLS=o.findall(a)
		thumbs=q.findall(a)
		x=0
		for title in match:
			thumb=thumbs[x][1]
			name = clean(match[x][1])
			date=time[x]
			date=date.rsplit('/', 2)
			date=date[1]
			date=date.lstrip('0')
			title='Episode '+date+' - '+name
			name = str(int(x+1))+'. '+title
			url=URLS[x]
			#thumb=thumbs[x]
			li=xbmcgui.ListItem(clean(name), iconImage=thumb, thumbnailImage=thumb)
			li.setInfo( type="Video", infoLabels={ "Title": clean(name), "Director": 'Revision3', "Studio": 'Revision3', "Genre": cat, "Plot": clean(info[x]) } )
			u=sys.argv[0]+"?mode=2&name="+urllib.quote_plus(title)+"&url="+urllib.quote_plus(url)+"&plot="+urllib.quote_plus(clean(info[x]))+"&cat="+urllib.quote_plus(cat)
			xbmcplugin.addDirectoryItem(int(sys.argv[1]),u,li)
			x=x+1
Esempio n. 5
0
def addDir(name,url,mode,iconimage,itemcount,isFolder=False):
        try:
          if not 'COLOR' in name:
            splitName=name.partition('(')
            simplename=""
            simpleyear=""
            if len(splitName)>0:
                simplename=splitName[0]
                simpleyear=splitName[2].partition(')')
            if len(simpleyear)>0:
                simpleyear=simpleyear[0]
            mg = metahandlers.MetaData()
            meta = mg.get_meta('movie', name=simplename ,year=simpleyear)
            u=sys.argv[0]+"?url="+urllib.quote_plus(url)+"&mode="+str(mode)+"&name="+urllib.quote_plus(name)+"&iconimage="+urllib.quote_plus(iconimage)
            ok=True
            liz=xbmcgui.ListItem(name, iconImage=meta['cover_url'], thumbnailImage=meta['cover_url'])
            liz.setInfo( type="Video", infoLabels= meta )
            liz.setProperty("IsPlayable","true")
            contextMenuItems = []
            contextMenuItems.append(('Movie Information', 'XBMC.Action(Info)'))
            liz.addContextMenuItems(contextMenuItems, replaceItems=False)
            if not meta['backdrop_url'] == '': liz.setProperty('fanart_image', meta['backdrop_url'])
            else: liz.setProperty('fanart_image', fanart)
            ok=xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=liz,isFolder=isFolder,totalItems=itemcount)
            return ok
        except:
            u=sys.argv[0]+"?url="+urllib.quote_plus(url)+"&mode="+str(mode)+"&name="+urllib.quote_plus(name)+"&iconimage="+urllib.quote_plus(iconimage)
            ok=True
            liz=xbmcgui.ListItem(name, iconImage="DefaultFolder.png", thumbnailImage=iconimage)
            liz.setInfo( type="Video", infoLabels={ "Title": name } )
            liz.setProperty('fanart_image', fanart)
            liz.setProperty("IsPlayable","true")
            ok=xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=liz,isFolder=isFolder)
            return ok
Esempio n. 6
0
def addMenu(url,title):
    listitem = xbmcgui.ListItem(decode(title), iconImage='', thumbnailImage='')
    fanart = addon.getAddonInfo('path') + '/fanart.jpg'

    listitem.setProperty('fanart_image', fanart)
    xbmcplugin.addDirectoryItem(plugin_handle, url, listitem,
                                isFolder=True, totalItems=0)
Esempio n. 7
0
	def list_episodes(self, movie_id):
		xbmcplugin.setContent(int(sys.argv[1]), 'episodes')
		query_params = {'movieid': movie_id}
		m = self.__request__('movie', query_params)['r']
		_id = m['MovieID']
		name = m['MovieName']
		aka = m['KnownAs']
		trailer = m['Trailer']
		poster = m['Poster']
		if 'Poster214x321' in m:
			poster = m['Poster214x321']
		runtime      = m['Runtime']
		plot         = m['PlotVI']
		rating       = m['ImdbRating']
		country      = m['Country']
		release_date = m['ReleaseDate']
		backdrop     = m['Backdrop']
		banner       = m['Banner']
		num_episodes = m['Episode']
		thumbs = sorted(m['Thumbs'].keys(), key=lambda x: int(x))
		for thumb in thumbs:
			t = unicode.join(u'',[u'Tập', ' ', thumb])
			item = xbmcgui.ListItem(t)
			item.setInfo(type="Video", infoLabels={"Label": name, "Title": t, "Plot": plot, 'Year': release_date})
			epThumb = m['Thumbs'][thumb]
			item.setArt({'poster': epThumb, 'thumb': epThumb})
			item.setProperty("Fanart_Image", backdrop)
			u = self.__build_url__({'action': 'play_movie', 'movie_id': _id, 'episode': thumb})
			xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=item,isFolder=False)
		xbmcplugin.endOfDirectory(int(sys.argv[1]), cacheToDisc=True)
Esempio n. 8
0
def view(items, update_listing=False, urls=None):
    if urls is None:
        urls = [plugin.url_for_path(item.url) for item in items]
    total = len(items)
    for item, url in zip(items, urls):
        if not getattr(item, 'available', True):
            continue
        title = item.title
        if getattr(item, 'episode', None):
            title += " " + item.episode
        li = ListItem(title, thumbnailImage=getattr(item, 'thumb', ''))
        playable = plugin.route_for(url) == play
        li.setProperty('isplayable', str(playable))
        if hasattr(item, 'fanart'):
            li.setProperty('fanart_image', item.fanart)
        if playable:
            info = {
                'title': title,
                'plot': item.description,
                'mpaa': item.legal_age,
            }
            if item.category:
                info['genre'] = item.category.title
            if item.aired:
                info['aired'] = item.aired.strftime('%Y-%m-%d')
            li.setInfo('video', info)
            li.addStreamInfo('video', {'codec': 'h264', 'width': 1280, 'height': 720, 'duration': item.duration})
            li.addStreamInfo('audio', {'codec': 'aac', 'channels': 2})
        addDirectoryItem(plugin.handle, url, li, not playable, total)
    endOfDirectory(plugin.handle, updateListing=update_listing)
Esempio n. 9
0
def Get_Header(par, count):

    if par.search == "":
        info = "Сериалов: " + "[COLOR FF00FF00]" + str(count) + "[/COLOR] | "
        info += "Жанр: " + "[COLOR FFFF00FF]" + par.genre_name + "[/COLOR] | "
        info += "Страна: " + "[COLOR FFFFF000]" + par.country_name + "[/COLOR]"
    else:
        info = "Поиск: " + "[COLOR FF00FFF0]" + par.search + "[/COLOR]"

    if info <> "":
        # -- info line
        name = info
        i = xbmcgui.ListItem(name, iconImage=icon, thumbnailImage=icon)
        u = sys.argv[0] + "?mode=EMPTY"
        # -- filter parameters
        u += "&genre=%s" % urllib.quote_plus(par.genre)
        u += "&genre_name=%s" % urllib.quote_plus(par.genre_name)
        u += "&country=%s" % urllib.quote_plus(par.country)
        u += "&country_name=%s" % urllib.quote_plus(par.country_name)
        xbmcplugin.addDirectoryItem(h, u, i, True)

    # -- genre
    if par.genre == "0" and par.search == "" and par.history == "":
        name = "[COLOR FFFF00FF]" + "[ЖАНР]" + "[/COLOR]"
        i = xbmcgui.ListItem(name, iconImage=icon, thumbnailImage=icon)
        u = sys.argv[0] + "?mode=GENRE"
        # -- filter parameters
        u += "&genre=%s" % urllib.quote_plus(par.genre)
        u += "&genre_name=%s" % urllib.quote_plus(par.genre_name)
        u += "&country=%s" % urllib.quote_plus(par.country)
        u += "&country_name=%s" % urllib.quote_plus(par.country_name)
        xbmcplugin.addDirectoryItem(h, u, i, True)

    # -- genre
    if par.country == "0" and par.search == "" and par.history == "":
        name = "[COLOR FFFFF000]" + "[СТРАНА]" + "[/COLOR]"
        i = xbmcgui.ListItem(name, iconImage=icon, thumbnailImage=icon)
        u = sys.argv[0] + "?mode=COUNTRY"
        # -- filter parameters
        u += "&genre=%s" % urllib.quote_plus(par.genre)
        u += "&genre_name=%s" % urllib.quote_plus(par.genre_name)
        u += "&country=%s" % urllib.quote_plus(par.country)
        u += "&country_name=%s" % urllib.quote_plus(par.country_name)
        xbmcplugin.addDirectoryItem(h, u, i, True)

    # -- search & history
    if par.country == "0" and par.genre == "0" and par.search == "" and par.history == "":
        name = "[COLOR FF00FFF0]" + "[ПОИСК]" + "[/COLOR]"
        i = xbmcgui.ListItem(name, iconImage=icon, thumbnailImage=icon)
        u = sys.argv[0] + "?mode=MOVIE"
        # -- filter parameters
        u += "&search=%s" % urllib.quote_plus("Y")
        xbmcplugin.addDirectoryItem(h, u, i, True)

        name = "[COLOR FF00FF00]" + "[ИСТОРИЯ]" + "[/COLOR]"
        i = xbmcgui.ListItem(name, iconImage=icon, thumbnailImage=icon)
        u = sys.argv[0] + "?mode=MOVIE"
        # -- filter parameters
        u += "&history=%s" % urllib.quote_plus("Y")
        xbmcplugin.addDirectoryItem(h, u, i, True)
Esempio n. 10
0
def panDir():
    while not panAuth():
        if xbmcgui.Dialog().yesno(_name, '          Login Failed', 'Bad User / Pass / Proxy', '       Check Settings?'):
            _settings.openSettings()
        else: exit()

    sort = _settings.getSetting('sort')
    stations = _pandora.stations
    quickmix = stations.pop(0)							# Quickmix
    if   sort == '0':	stations = stations					# Normal
    elif sort == '2':	stations = stations[::-1]				# Reverse
    else:		stations = sorted(stations, key=lambda s: s.name)	# A-Z
    stations.insert(0, quickmix)						# Quickmix back on top

    for station in stations:
        li = xbmcgui.ListItem(station.name, station.id)
        li.setProperty('IsPlayable', 'true')

        img = _settings.getSetting("img-%s" % station.id)
        li.setIconImage(img)
        li.setThumbnailImage(img)
        li.addContextMenuItems([('Select Thumb', "RunPlugin(plugin://%s/?thumb=%s)" % (_plugin, station.id))])

        xbmcplugin.addDirectoryItem(_handle, "%s?station=%s" % (_base, station.id), li)

    xbmcplugin.endOfDirectory(_handle, cacheToDisc = False)
    xbmc.log("%s.Dir   OK" % _plugin, xbmc.LOGDEBUG)
def addDir(title, url, mode, page=0, searchValue=''):
    sys_url = sys.argv[0] + '?title=' + urllib.quote_plus(title) + '&url=' + urllib.quote_plus(url) + \
              '&mode=' + urllib.quote_plus(str(mode)) + '&page=' + urllib.quote_plus(str(page))+'&search'+\
              urllib.quote_plus(str(searchValue))

    item = xbmcgui.ListItem(title, iconImage='DefaultFolder.png', thumbnailImage='')
    xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sys_url, listitem=item, isFolder=True)
Esempio n. 12
0
def schedule247():
    import datetime
    import time
    i = datetime.datetime.now()
    day,month,year=i.day, i.month, i.year
    s="%s/%s/%s"%(day,month,year)
    time=time.mktime(datetime.datetime.strptime(s, "%d/%m/%Y").timetuple())
    time=str(time).replace('.0','')+'000'
    url='https://tockify.com/api/readEventView?calname=pilkalive&max=30&start-inclusive=true&startms='+time
    txt=json.loads(read_url(url))
    events=txt['events']
    for i in range (len(events)):
        time=events[i]['when']['start']['millis']
        time=str(time)[:-3]
        event=events[i]['content']['summary']['text']
        link=events[i]['content']['description']['text']

        ts = datetime.datetime.fromtimestamp(float(time))
        year,month,day,hour,minute=ts.strftime('%Y'),ts.strftime('%m'),ts.strftime('%d'),ts.strftime('%H'),ts.strftime('%M')
        from utils import pytzimp
        d = pytzimp.timezone(str(pytzimp.timezone('Europe/Madrid'))).localize(datetime.datetime(2000 + int(year), int(month), int(day), hour=int(hour), minute=int(minute)))
        timezona= addon.get_setting('timezone_new')
        my_location=pytzimp.timezone(pytzimp.all_timezones[int(timezona)])
        convertido=d.astimezone(my_location)
        fmt = "%d-%m-%y [COLOR green]%H:%M[/COLOR]"

        time=convertido.strftime(fmt)
        event=event[5:]
        title='([COLOR blue][B]%s[/B][/COLOR]) [B][COLOR orange]%s[/COLOR][/B]'%(time,event)
        url = build_url({'mode': 'open_247_event','url':link})
        li = xbmcgui.ListItem(title,iconImage='')
        xbmcplugin.addDirectoryItem(handle=addon_handle, url=url,
                                listitem=li, isFolder=True)
    xbmcplugin.endOfDirectory(addon_handle)
Esempio n. 13
0
def ttv_sport():
    base_url = 'http://super-pomoyka.us.to/trash/ttv-list/ttv.m3u'
    source = read_url(base_url)
    if source:
        match= re.compile("#EXTINF:-1,Sky Sports News \(.+?\)\n(.*)").findall(source)
        if match: 
            name='Sky Sports News'
            ace=match[0]
            url='plugin://program.plexus/?mode=1&url=%s&name=%s'%(ace,name.replace(' ','+'))
            li = xbmcgui.ListItem('%s'%name, iconImage='http://addons.tvaddons.ag/cache/images/bc591d6d5ec442d4ddb43a347a8be6_icon.png')
            li.setProperty('IsPlayable', 'true')
            xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li)

        match= re.compile("#EXTINF:-1,(.+?)\(Спорт\)\n(.*)").findall(source)
        for titulo,acestream in match:
            name=titulo
            ace=acestream
            clean = re.compile("\((.+?)\)").findall(name)
            for categorie in clean:
                name = name.replace("(" + categorie +")","")
                ace=acestream
            url='plugin://program.plexus/?mode=1&url=%s&name=%s'%(ace,name.replace(' ','+'))
            li = xbmcgui.ListItem('%s'%name, iconImage='http://addons.tvaddons.ag/cache/images/bc591d6d5ec442d4ddb43a347a8be6_icon.png')
            li.setProperty('IsPlayable', 'true')
            xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li)
    xbmcplugin.endOfDirectory(addon_handle)
Esempio n. 14
0
def ttv_cats():
	dict_torrent = {}
	url="http://super-pomoyka.us.to/trash/ttv-list/ttv.m3u"
	html_source=read_url(url)
	match = re.compile('#EXTINF:-1,(.+?)\n(.*)').findall(html_source)
	for title, acehash in match:
    		channel_name = re.compile('(.+?) \(').findall(title)
    		match_cat = re.compile('\((.+?)\)').findall(title)
    		for i in xrange(0,len(match_cat)):
    			if match_cat[i] == "Для взрослых" :
    				pass
    			elif match_cat[i] == "Ночной канал" :
                                pass
    			else:
                		categorie = russiandictionary(match_cat[i])
                		
                		if categorie not in dict_torrent.keys():
                			try:
            					dict_torrent[categorie] = [(channel_name[0],acehash)]
            				except: pass
            			else:
            				try:
            					dict_torrent[categorie].append((channel_name[0],acehash))
            				except: pass
	for cat in dict_torrent.keys():
		url = build_url({'mode': 'open_ttv_cat','channels':json.dumps(dict_torrent),'cat':cat})
		li = xbmcgui.ListItem(cat,iconImage='http://addons.tvaddons.ag/cache/images/bc591d6d5ec442d4ddb43a347a8be6_icon.png')
		xbmcplugin.addDirectoryItem(handle=addon_handle, url=url,
				listitem=li, isFolder=True)
		

	xbmcplugin.endOfDirectory(addon_handle)
Esempio n. 15
0
def get_ttv():
    url='http://www.acesportstream.com'
    url=read_url(url)
    soup=bs(url)
    channels1=soup.find('div',{'id':'hd'}).findAll('a')
    channels2=soup.find('div',{'id':'blue'}).findAll('a')

    
    for channel in channels1:
        link=channel['href']
        img=channel.find('img')['src']
        name=clean(cleanex(channel['title']))

        url = build_url({'mode': 'open_ttv_stream','url':link, 'name':name.encode('ascii','ignore')})
        li = xbmcgui.ListItem('%s'%name, iconImage=img)
        li.setProperty('IsPlayable', 'true')

        xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li)
    for channel in channels2:
        link=channel['href']
        img=channel.find('img')['src']
        name=clean(cleanex(channel['title']))

        url = build_url({'mode': 'open_ttv_stream','url':link, 'name':name.encode('ascii','ignore')})
        li = xbmcgui.ListItem('%s'%name, iconImage=img)
        li.setProperty('IsPlayable', 'true')

        xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li)

    
    xbmcplugin.endOfDirectory(addon_handle)
Esempio n. 16
0
    def channelList(self, channelList):
        count = 0
        total = len(channelList)
        for i in channelList:
            try:
                name, epg = i['name'], i['epg']
                if getSetting(name) == "false": raise Exception()
                sysname = urllib.quote_plus(name.replace(' ','_'))

                u = '%s?action=play&channel=%s&t=%s' % (sys.argv[0], sysname, datetime.datetime.now().strftime("%Y%m%d%H%M%S%f"))
                meta = {'Label': name, 'Title': name, 'Studio': name, 'Duration': '1440', 'Plot': epg}

                image = '%s/%s.png' % (addonLogos, re.sub('\s[(]\d{1}[)]','', name))
                fanart = '%s/%s.jpg' % (addonSlideshow, str(count)[-1])
                count = count + 1

                cm = []
                cm.append((language(30401).encode("utf-8"), 'RunPlugin(%s?action=epg_menu&channel=%s)' % (sys.argv[0], sysname)))
                cm.append((language(30404).encode("utf-8"), 'RunPlugin(%s?action=refresh)' % (sys.argv[0])))

                item = xbmcgui.ListItem(name, iconImage=image, thumbnailImage=image)
                item.setInfo( type="Video", infoLabels = meta )
                #item.setProperty("IsPlayable", "true")
                item.setProperty("Video", "true")
                item.setProperty("Fanart_Image", fanart)
                item.addContextMenuItems(cm, replaceItems=False)
                xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=item,totalItems=total,isFolder=False)
            except:
                pass
Esempio n. 17
0
def addDir(name, url, mode, iconimage, description):
    u = (
        sys.argv[0]
        + "?url="
        + urllib.quote_plus(url)
        + "&mode="
        + str(mode)
        + "&name="
        + urllib.quote_plus(name)
        + "&iconimage="
        + urllib.quote_plus(iconimage)
        + "&description="
        + urllib.quote_plus(description)
    )
    ok = True
    liz = xbmcgui.ListItem(name, iconImage="DefaultFolder.png", thumbnailImage=iconimage)
    liz.setInfo(type="Video", infoLabels={"Title": name, "Plot": description})
    if mode == 1:
        ok = xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=u, listitem=liz)
    elif mode == 3 or mode == 5:
        liz.setProperty("IsPlayable", "true")
        ok = xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=u, listitem=liz, isFolder=False)
    else:
        ok = xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=u, listitem=liz, isFolder=True)
    return ok
Esempio n. 18
0
def getTags(params):
    http = GET(httpSiteUrl + '/tags/', httpSiteUrl)
    if http == None: return False

    beautifulSoup = BeautifulSoup(http)
    tagsContainer = beautifulSoup.find('td', 'news')
    tags = tagsContainer.findAll('a')
    if len(tags) == 0:
        showMessage('ОШИБКА', 'Неверная страница', 3000)
        return False
    else:
        tags.reverse()
        for link in tags:
            if link != None:
                title = link.string
                href = link['href']
                if href.find("://") < 0:
                    href = httpSiteUrl + href
                li = xbmcgui.ListItem('[%s]' % title)
                li.setProperty('IsPlayable', 'false')
                uri = construct_request({
                'href': href,
                'mode': 'readCategory'
                })
                xbmcplugin.addDirectoryItem(h, uri, li, True)

    xbmcplugin.endOfDirectory(h)
Esempio n. 19
0
 def add(self, service, name, category, title, iconimage, url, desc, page, folder=True, isPlayable=True):
     u = (
         sys.argv[0]
         + "?service="
         + service
         + "&name="
         + name
         + "&category="
         + category
         + "&title="
         + title
         + "&url="
         + urllib.quote_plus(url)
         + "&icon="
         + urllib.quote_plus(iconimage)
         + "&page="
         + urllib.quote_plus(page)
     )
     # log.info(str(u))
     if name == "main-menu" or name == "categories-menu":
         title = category
     if iconimage == "":
         iconimage = "DefaultVideo.png"
     liz = xbmcgui.ListItem(title, iconImage="DefaultFolder.png", thumbnailImage=iconimage)
     liz.setProperty("fanart_image", iconimage)
     if isPlayable:
         liz.setProperty("IsPlayable", "true")
     liz.setInfo(
         type="Video", infoLabels={"Title": title, "Plot": desc, "Episode": "AAA", "Year": "2000", "Genre": "bbb"}
     )
     xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=u, listitem=liz, isFolder=folder)
def Movies(url):
	html = getHTML(url)

	png_links = re.compile('<img class="lazy" data-original="(.+?)" src="').findall(html)
	movie_links = re.compile('<a href="(.+?)" class="a ajax">\s+<span class="s1 ptsans_bold"><span class="hfx">(.+?)</span></span>').findall(html)
	
	item = xbmcgui.ListItem('[B]Категории[/B]', iconImage='DefaultFolder.png', thumbnailImage='')
	xbmcplugin.addDirectoryItem(_addon_id, 'plugin://plugin.video.kaztube/' , item, True)	
	
#	if _url_page > 1:
#		back_page = _url_page - 1
#		addDir('[COLOR F5DEB300]Назад[/COLOR]', url, 20, '', True, back_page)
		
	i = 0
	all = []

	for link, name in movie_links:
		all.append( (link, name, png_links[i] ) )
		i = i + 1

	for link, title, png in all:
		addDir(title, link, 30, png, False, 0)
	
	pages = re.compile('page="(.+?)" href="').findall(html)
		
	max_page = 0
	if pages:
		max_page = int(pages[-1])
		next_page = _url_page + 1
		if next_page <= max_page:
			addDir('[COLOR F5DEB300]Загрузить еще[/COLOR]', url, 20, '', True, next_page)
Esempio n. 21
0
def getCategories(params):
    categoryUrl = urllib.unquote_plus(params['href'])
    http = GET(categoryUrl, httpSiteUrl)
    if http == None: return False

    beautifulSoup = BeautifulSoup(http)
    categoryContainer = beautifulSoup.find('ul', 'cats')
    categories = categoryContainer.findAll('a')
    if len(categories) == 0:
        showMessage('ОШИБКА', 'Неверная страница', 3000)
        return False
    else:
        for link in categories:
            if link != None:
                title = link.string
                if title == None:
                    title = link.find("h2").string
                href = link['href']
                if href.find("://") < 0:
                    href = httpSiteUrl + href
                li = xbmcgui.ListItem('[%s]' % title)
                li.setProperty('IsPlayable', 'false')
                uri = construct_request({
                'href': href,
                'mode': 'readCategory'
                })
                xbmcplugin.addDirectoryItem(h, uri, li, True)

    xbmcplugin.endOfDirectory(h)
Esempio n. 22
0
def addVideo(linkName = '', source = '', videoID = '', thumbPath = '', date = ''):
    
    """Add a video to an XBMC directory listing
    
    Arguments:  linkName -- A string containg the name of the video
                url -- A string containing the direct url to the video
                thumbPath -- A string containg the url/path of the video's thumbnail image
                date -- a dataetime object containg the date of the video"""
    
    url = sys.argv[0] + "?source=" + source + "&id=" + videoID
    
    # initialise a listitem object to store video details
    li = xbmcgui.ListItem(linkName, iconImage = thumbPath, thumbnailImage = thumbPath)
    
    # set the video to playable
    li.setProperty("IsPlayable", 'true')
    
    # set the infolabels for the video
    li.setInfo( type="Video", infoLabels={ "title": linkName, "date":date} )
    
    # set fanart image for video
    li.setProperty( "Fanart_Image", os.path.join(__addondir__, 'fanart.jpg'))
    
    # add listitem object to list
    xbmcplugin.addDirectoryItem(handle = __addonidint__, url = url, listitem = li, isFolder = False)
Esempio n. 23
0
    def _addDir(self, name, action_key, action_value, iconimage, is_folder):
        """
        .. py_function:: _addDir(self, name, action_key, action_value,
                            iconimage, is_folder)

        Creates a link in xbmc.

        :param name: Name of the link
        :param action_key: Name of the action to take when link selected
        :param action_value: Parameter to use with the action
        :param iconimage: Icon to use for the link
        :param is_folder: Does the link lead to a folder or playable item

        """
        formatparams = {
            "base_url": self.base_url,
            "key": quote(str(action_key)),
            "value": quote(str(action_value)),
            "name": quote(str(name))
        }

        url = "{base_url}?action_key={key}&action_value={value}&name={name}".format(**formatparams)

        listitem = xbmcgui.ListItem(name,
                                    iconImage=iconimage,
                                    thumbnailImage='')
        listitem.setInfo(type="Video", infoLabels={"Title": name})

        xbmcplugin.addDirectoryItem(
            handle=self.addon_handle,
            url=url,
            listitem=listitem,
            isFolder=is_folder)
def addLink(name,url,title,iconimage):
    if iconimage == '':
        iconimage = ICON
    liz=xbmcgui.ListItem(name, iconImage=iconimage, thumbnailImage=iconimage)
    liz.setInfo( type="Video", infoLabels={ "Title": title } )
    liz.setProperty('fanart_image',FANART)
    xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=url,listitem=liz)
def addVideoDirR(name, url, mode, iconimage, videoType="", desc="", duration="", year="", mpaa="", director="", genre="", rating=""):
    filename = (''.join(c for c in unicode(url, 'utf-8') if c not in '/\\:?"*|<>')).strip()+".jpg"
    coverFile = os.path.join(cacheFolderCoversTMDB, filename)
    fanartFile = os.path.join(cacheFolderFanartTMDB, filename)
    if os.path.exists(coverFile):
        iconimage = coverFile
    u = sys.argv[0]+"?url="+urllib.quote_plus(url)+"&mode="+str(mode)+"&name="+urllib.quote_plus(name)+"&thumb="+urllib.quote_plus(iconimage)
    ok = True
    liz = xbmcgui.ListItem(name, iconImage="DefaultTVShows.png", thumbnailImage=iconimage)
    liz.setInfo(type="video", infoLabels={"title": name, "plot": desc, "duration": duration, "year": year, "mpaa": mpaa, "director": director, "genre": genre, "rating": rating})
    if os.path.exists(fanartFile):
        liz.setProperty("fanart_image", fanartFile)
    elif os.path.exists(coverFile):
        liz.setProperty("fanart_image", coverFile)
    entries = []
    entries.append((translation(30134), 'RunPlugin(plugin://plugin.video.netflixbmc/?mode=playTrailer&url='+urllib.quote_plus(name)+')',))
    entries.append((translation(30115), 'RunPlugin(plugin://plugin.video.netflixbmc/?mode=removeFromQueue&url='+urllib.quote_plus(url)+')',))
    if videoType == "tvshow":
        entries.append((translation(30122), 'RunPlugin(plugin://plugin.video.netflixbmc/?mode=addSeriesToLibrary&url=&name='+str(name.strip())+'&seriesID='+str(url)+')',))
        if browseTvShows:
            entries.append((translation(30121), 'Container.Update(plugin://plugin.video.netflixbmc/?mode=playVideo&url='+urllib.quote_plus(url)+'&thumb='+urllib.quote_plus(iconimage)+')',))
        else:
            entries.append((translation(30118), 'Container.Update(plugin://plugin.video.netflixbmc/?mode=listSeasons&url='+urllib.quote_plus(url)+'&thumb='+urllib.quote_plus(iconimage)+')',))
    elif videoType == "movie":
        entries.append((translation(30122), 'RunPlugin(plugin://plugin.video.netflixbmc/?mode=addMovieToLibrary&url='+urllib.quote_plus(url)+'&name='+str(name.strip()+' ('+year+')')+')',))
    liz.addContextMenuItems(entries)
    if mode == "playVideo":
        ok = xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=u, listitem=liz, isFolder=False)
    else:
        ok = xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=u, listitem=liz, isFolder=True)
    return ok
Esempio n. 26
0
def INC_start():
    
    dbg_log('-INC_start')

    http = get_url(INC_urlw + '/index.php', save_cookie = True)
    mycookie = re.search('<cookie>(.+?)</cookie>', http).group(1)
    http = get_url(INC_urlw + INC_auth, 
                  data = "LoginForm%5Busername%5D=" + urllib.quote_plus(usr_log) + "&LoginForm%5Bpassword%5D=" + urllib.quote_plus(usr_pwd),
                  cookie = mycookie, save_cookie = True, referrer = INC_urlw + '/index.php', accept='json')
    try:
      mycookie = re.search('<cookie>(.+?)</cookie>', http).group(1)
    except:
      pass
                  
                  
    http = get_url(INC_urlw + '/index.php', cookie = mycookie)
    #mycookie = re.search('<cookie>(.+?)</cookie>', http).group(1)                  

    name='Live TV'
    item = xbmcgui.ListItem(name)
    uri = sys.argv[0] + '?mode=live' + '&cook=' + urllib.quote_plus(mycookie)
    xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)

    name='Archives'
    item = xbmcgui.ListItem(name)
    uri = sys.argv[0] + '?mode=chls' + '&cook=' + urllib.quote_plus(mycookie)
    xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)  

    xbmcplugin.endOfDirectory(pluginhandle)  
Esempio n. 27
0
def PlayVideo1(url, listitem):
        addon_handle = int(sys.argv[1])
        xbmcplugin.setContent(addon_handle, 'video')
        li = xbmcgui.ListItem('[COLOR dodgerblue][B]PLAY STREAM[/B][/COLOR]  >> ', iconImage='http://maps.synthicity.com/activemaps/images/button_black_play.png', thumbnailImage= 'http://maps.synthicity.com/activemaps/images/button_black_play.png')
        li.setProperty('fanart_image', 'https://raw.githubusercontent.com/TheYid/My-Repo/master/repository.TheYid/fanart.jpg')
        xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li)
        xbmcplugin.endOfDirectory(addon_handle)
Esempio n. 28
0
def addDir(title, url, mode):
    sys_url = sys.argv[0] + '?title=' + urllib.quote_plus(title) + '&url=' + urllib.quote_plus(url) + '&mode=' + urllib.quote_plus(str(mode))

    item = xbmcgui.ListItem(title, iconImage='DefaultFolder.png', thumbnailImage='')
    item.setInfo( type='Video', infoLabels={'Title': title} )

    xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sys_url, listitem=item, isFolder=True)
Esempio n. 29
0
def INC_live(url, mycookie):
    dbg_log('INC_live')
    
    http = get_url(url, cookie = mycookie, referrer = INC_urlw + '/index.php')

#    guest = re.compile('var isGuest=(.+?);').findall(http)
#    print '--GUEST--'
#    print guest
      
    oneline = re.sub('[\r\n]', ' ', http)
    pr_ls = re.compile('<tr > +?<td class="col01"><a href="(.+?)"><img src="(.+?)"  alt="(.+?)" /></a></td>').findall(oneline)

    if len(pr_ls):
        for href,logo,descr in pr_ls:
            name = descr
            dbg_log(name)
            item = xbmcgui.ListItem(name, iconImage=INC_url + logo, thumbnailImage=INC_url + logo)
            uri = sys.argv[0] + '?mode=play'
            uri += '&url='+urllib.quote_plus(INC_urlw + href) + '&cook=' + urllib.quote_plus(mycookie)
            item.setInfo( type='video', infoLabels={'title': name, 'plot': descr})
            item.setProperty('IsPlayable', 'true')
            dbg_log(uri)
            xbmcplugin.addDirectoryItem(pluginhandle, uri, item)

    xbmcplugin.endOfDirectory(pluginhandle)    
def addDir(title, url, mode, png, is_cat, page):
	sys_url = sys.argv[0] + '?title=' + urllib.quote_plus(title) + '&url=' + urllib.quote_plus(url)

	if page > 0:
		if url[-1] == '/':
			sys_url = sys_url + urllib.quote_plus( '?page='+str(page) )
		else:
			sys_url = sys_url + urllib.quote_plus( '&page='+str(page) )
	
	sys_url = sys_url + '&mode=' + urllib.quote_plus(str(mode)) 
	
	if png:
		spng = 'http://kaztube.kz' + png
		sys_url = sys_url + '&png=' + urllib.quote_plus(spng)
	else:
		spng = ''
	
	if page > 0:
		sys_url = sys_url + '&page=' + urllib.quote_plus(str(page))
		
	
	item = xbmcgui.ListItem(title, iconImage='DefaultFolder.png', thumbnailImage=spng)
	item.setInfo( type='Video', infoLabels={'Title': title} )

	xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sys_url, listitem=item, isFolder=is_cat)
Esempio n. 31
0
def addText(name):
    item = xbmcgui.ListItem(name)
    item.setProperty('IsPlayable', 'false')
    xbmcplugin.addDirectoryItem(handle=pluginhandle,
                                url=sys.argv[0],
                                listitem=item)
            list_item = xbmcgui.ListItem(label=languages[subtitle['subLang']],
                                         label2=subtitle['subName'],
                                         thumbnailImage=xbmc.convertLanguage(
                                             subtitle["subLang"],
                                             xbmc.ISO_639_1))

            plugin_url = "plugin://{path}/?{query}".format(
                path=__scriptid__,
                query=urllib.urlencode(
                    dict(action='download',
                         link=subtitle['subDownloadLink'],
                         file_name=subtitle['subName'],
                         format=subtitle['subFormat'])))
            log("BSPlayer.plugin_url", "Plugin Url Created: %s." % plugin_url)
            xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),
                                        url=plugin_url,
                                        listitem=list_item,
                                        isFolder=False)
elif params['action'] == 'manualsearch':
    notify(__scriptname__, __language__, 32002)
    log("BSPlayer.manualsearch", "Manual search not supported.")
elif params['action'] == 'download':
    if xbmcvfs.exists(__temp__):
        shutil.rmtree(__temp__)
    xbmcvfs.mkdirs(__temp__)

    if params['format'] in ["srt", "sub", "txt", "smi", "ssa", "ass"]:
        subtitle_path = path.join(__temp__, params['file_name'])
        if BSPlayer.download_subtitles(params['link'], subtitle_path):
            log("BSPlayer.download_subtitles",
                "Subtitles Download Successfully From: %s." % params['link'])
            list_item = xbmcgui.ListItem(label=subtitle_path)
Esempio n. 33
0
 def make_selectable(self, name, url):
     li = ListItem(name, iconImage='DefaultUser.png')
     li.setProperty('IsPlayable', 'False')
     li.setInfo("video",
                {'mediatype': 'video'})  # needed to make it selectable?
     addDirectoryItem(self.handle, url=url, listitem=li)
Esempio n. 34
0
 def make_folder(self, folder_name, url, icon_name):
     li = ListItem(folder_name, iconImage=icon_name)
     li.setProperty('IsPlayable', 'False')
     addDirectoryItem(self.handle, url=url, listitem=li, isFolder=True)
Esempio n. 35
0
def generate_list_items(xml, href, foldername, nametree):
    """ Will generate a list of directory items for the UI based on the xml values. """
    for group in xml.getiterator('group'):
        if group.attrib.get('href') == href:
            continue

        # Build up the name tree.
        name = group.attrib.get('name').encode('ascii', 'ignore')
        url = build_url({
            'mode': group.attrib.get('type'),
            'foldername': name,
            'href': group.attrib.get('href'),
            'parenthref': href,
            'nametree': nametree + '/' + name
        })

        if group.attrib.get('art') == None:
            image = 'DefaultVideo.png'
        else:
            image = playonInternalUrl + group.attrib.get('art')

        if group.attrib.get('type') == 'folder':
            try:
                from metahandler import metahandlers
                metaget = metahandlers.MetaData()

                #Get a movie
                #Media type and movie name are required, imdb id will give you exact match, if no imdb id then include the year for more accurate match
                #Media type and Name are required, rest are optional
                # meta=metaget.get_meta('movie', name)

                meta = metaget.get_meta('movie', name)

                li = xbmcgui.ListItem(name,
                                      iconImage=meta['cover_url'],
                                      thumbnailImage=meta['cover_url'])
                li.setInfo(type="Video", infoLabels=meta)
                li.setProperty('fanart_image', meta['backdrop_url'])
            except Exception, e:
                print str(e)
                li = xbmcgui.ListItem(name,
                                      iconImage=image,
                                      thumbnailImage=image)
                xbmcplugin.addDirectoryItem(handle=addonHandle,
                                            url=url,
                                            listitem=li,
                                            isFolder=True)

        elif group.attrib.get('type') == 'video':
            playonUrl = build_playon_url(group.attrib.get('href'))
            mediaXml = get_xml(playonUrl)
            mediaNode = mediaXml.find('media')
            try:
                from metahandler import metahandlers
                metaget = metahandlers.MetaData()

                #Get a movie
                #Media type and movie name are required, imdb id will give you exact match, if no imdb id then include the year for more accurate match
                #Media type and Name are required, rest are optional
                # meta=metaget.get_meta('movie', name)

                meta = metaget.get_meta('movie', name)

                li = xbmcgui.ListItem(name,
                                      iconImage=meta['cover_url'],
                                      thumbnailImage=meta['cover_url'])
                li.setInfo(type="Video", infoLabels=meta)
                li.setProperty('fanart_image', meta['backdrop_url'])
            except Exception, e:
                print str(e)
                li = xbmcgui.ListItem(name,
                                      iconImage=image,
                                      thumbnailImage=image)
                li.setInfo('video', {
                    'plotoutline': group.attrib.get('description'),
                    'title': name
                })
Esempio n. 36
0
                li = xbmcgui.ListItem(name,
                                      iconImage=meta['cover_url'],
                                      thumbnailImage=meta['cover_url'])
                li.setInfo(type="Video", infoLabels=meta)
                li.setProperty('fanart_image', meta['backdrop_url'])
            except Exception, e:
                print str(e)
                li = xbmcgui.ListItem(name,
                                      iconImage=image,
                                      thumbnailImage=image)
                li.setInfo('video', {
                    'plotoutline': group.attrib.get('description'),
                    'title': name
                })
            xbmcplugin.addDirectoryItem(handle=addonHandle,
                                        url=url,
                                        listitem=li)

    xbmcplugin.endOfDirectory(addonHandle)


#
#    Main Loop

log_message("Base URL:" + baseUrl, True)
log_message("Addon Handle:" + str(addonHandle), True)
log_message("Arguments", True)
log_message(args, True)

# Pull out the URL arguments for usage.
mode = get_argument_value('mode')
def addLink(name,url,iconimage):
        ok=True
        liz=xbmcgui.ListItem(name, iconImage="DefaultVideo.png", thumbnailImage=iconimage)
        liz.setInfo( type="Video", infoLabels={ "Title": name } )
        ok=xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=url,listitem=liz)
        return ok
Esempio n. 38
0
def getRecentEpisodes(viewid, mediatype, tagname, limit):
    count = 0
    # if the addon is called with recentepisodes parameter,
    # we return the recentepisodes list of the given tagname
    xbmcplugin.setContent(HANDLE, 'episodes')
    appendShowTitle = settings('RecentTvAppendShow') == 'true'
    appendSxxExx = settings('RecentTvAppendSeason') == 'true'
    # First we get a list of all the TV shows - filtered by tag
    params = {
        'sort': {
            'order': "descending",
            'method': "dateadded"
        },
        'filter': {
            'operator': "is",
            'field': "tag",
            'value': "%s" % tagname
        },
    }
    result = JSONRPC('VideoLibrary.GetTVShows').execute(params)
    # If we found any, find the oldest unwatched show for each one.
    try:
        items = result['result'][mediatype]
    except (KeyError, TypeError):
        # No items, empty folder
        xbmcplugin.endOfDirectory(handle=HANDLE)
        return

    allshowsIds = set()
    for item in items:
        allshowsIds.add(item['tvshowid'])
    params = {
        'sort': {
            'order': "descending",
            'method': "dateadded"
        },
        'properties': [
            "title", "playcount", "season", "episode", "showtitle", "plot",
            "file", "rating", "resume", "tvshowid", "art", "streamdetails",
            "firstaired", "runtime", "cast", "writer", "dateadded",
            "lastplayed"
        ],
        "limits": {
            "end": limit
        }
    }
    if settings('TVShowWatched') == 'false':
        params['filter'] = {
            'operator': "lessthan",
            'field': "playcount",
            'value': "1"
        }
    result = JSONRPC('VideoLibrary.GetEpisodes').execute(params)
    try:
        episodes = result['result']['episodes']
    except (KeyError, TypeError):
        pass
    else:
        for episode in episodes:
            if episode['tvshowid'] in allshowsIds:
                li = createListItem(episode,
                                    appendShowTitle=appendShowTitle,
                                    appendSxxExx=appendSxxExx)
                xbmcplugin.addDirectoryItem(handle=HANDLE,
                                            url=episode['file'],
                                            listitem=li)
                count += 1

            if count == limit:
                break

    xbmcplugin.endOfDirectory(handle=HANDLE)
Esempio n. 39
0
def addLink(contentType, name, url, iconimage='DefaultFolder.png', time='', sub=''):
        liz = xbmcgui.ListItem(clean(contentType, name), iconImage="DefaultVideo.png", thumbnailImage=iconimage)
        liz.setInfo(type="Video", infoLabels={ "Title": urllib.unquote(clean(contentType, name)), "Duration":time, "Plot": urllib.unquote(sub)})
        ok = xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=liz)
        return ok
Esempio n. 40
0
def getOnDeck(viewid, mediatype, tagname, limit):
    """
    Retrieves Plex On Deck items, currently only for TV shows

    Input:
        viewid:             Plex id of the library section, e.g. '1'
        mediatype:          Kodi mediatype, e.g. 'tvshows', 'movies',
                            'homevideos', 'photos'
        tagname:            Name of the Plex library, e.g. "My Movies"
        limit:              Max. number of items to retrieve, e.g. 50
    """
    xbmcplugin.setContent(HANDLE, 'episodes')
    appendShowTitle = settings('OnDeckTvAppendShow') == 'true'
    appendSxxExx = settings('OnDeckTvAppendSeason') == 'true'
    directpaths = settings('useDirectPaths') == 'true'
    if settings('OnDeckTVextended') == 'false':
        # Chances are that this view is used on Kodi startup
        # Wait till we've connected to a PMS. At most 30s
        counter = 0
        while window('plex_authenticated') != 'true':
            counter += 1
            if counter >= 300:
                log.error('Aborting On Deck view, we were not authenticated '
                          'for the PMS')
                return xbmcplugin.endOfDirectory(HANDLE, False)
            sleep(100)
        xml = downloadutils.DownloadUtils().downloadUrl(
            '{server}/library/sections/%s/onDeck' % viewid)
        if xml in (None, 401):
            log.error('Could not download PMS xml for view %s' % viewid)
            return xbmcplugin.endOfDirectory(HANDLE)
        limitcounter = 0
        for item in xml:
            api = API(item)
            listitem = api.CreateListItemFromPlexItem(
                appendShowTitle=appendShowTitle, appendSxxExx=appendSxxExx)
            if directpaths:
                url = api.getFilePath()
            else:
                params = {
                    'mode': "play",
                    'id': api.getRatingKey(),
                    'dbid': listitem.getProperty('dbid')
                }
                url = "plugin://plugin.video.plexkodiconnect/tvshows/?%s" \
                      % urlencode(params)
            xbmcplugin.addDirectoryItem(handle=HANDLE,
                                        url=url,
                                        listitem=listitem)
            limitcounter += 1
            if limitcounter == limit:
                break
        return xbmcplugin.endOfDirectory(
            handle=HANDLE,
            cacheToDisc=settings('enableTextureCache') == 'true')

    # if the addon is called with nextup parameter,
    # we return the nextepisodes list of the given tagname
    # First we get a list of all the TV shows - filtered by tag
    params = {
        'sort': {
            'order': "descending",
            'method': "lastplayed"
        },
        'filter': {
            'and': [{
                'operator': "true",
                'field': "inprogress",
                'value': ""
            }, {
                'operator': "is",
                'field': "tag",
                'value': "%s" % tagname
            }]
        }
    }
    result = JSONRPC('VideoLibrary.GetTVShows').execute(params)
    # If we found any, find the oldest unwatched show for each one.
    try:
        items = result['result'][mediatype]
    except (KeyError, TypeError):
        # Now items retrieved - empty directory
        xbmcplugin.endOfDirectory(handle=HANDLE)
        return

    params = {
        'sort': {
            'method': "episode"
        },
        'limits': {
            "end": 1
        },
        'properties': [
            "title", "playcount", "season", "episode", "showtitle", "plot",
            "file", "rating", "resume", "tvshowid", "art", "streamdetails",
            "firstaired", "runtime", "cast", "writer", "dateadded",
            "lastplayed"
        ],
    }
    if settings('ignoreSpecialsNextEpisodes') == "true":
        params['filter'] = {
            'and': [{
                'operator': "lessthan",
                'field': "playcount",
                'value': "1"
            }, {
                'operator': "greaterthan",
                'field': "season",
                'value': "0"
            }]
        }
    else:
        params['filter'] = {
            'or': [{
                'operator': "lessthan",
                'field': "playcount",
                'value': "1"
            }, {
                'operator': "true",
                'field': "inprogress",
                'value': ""
            }]
        }

    # Are there any episodes still in progress/not yet finished watching?!?
    # Then we should show this episode, NOT the "next up"
    inprog_params = {
        'sort': {
            'method': "episode"
        },
        'filter': {
            'operator': "true",
            'field': "inprogress",
            'value': ""
        },
        'properties': params['properties']
    }

    count = 0
    for item in items:
        inprog_params['tvshowid'] = item['tvshowid']
        result = JSONRPC('VideoLibrary.GetEpisodes').execute(inprog_params)
        try:
            episodes = result['result']['episodes']
        except (KeyError, TypeError):
            # No, there are no episodes not yet finished. Get "next up"
            params['tvshowid'] = item['tvshowid']
            result = JSONRPC('VideoLibrary.GetEpisodes').execute(params)
            try:
                episodes = result['result']['episodes']
            except (KeyError, TypeError):
                # Also no episodes currently coming up
                continue
        for episode in episodes:
            # There will always be only 1 episode ('limit=1')
            li = createListItem(episode,
                                appendShowTitle=appendShowTitle,
                                appendSxxExx=appendSxxExx)
            xbmcplugin.addDirectoryItem(handle=HANDLE,
                                        url=episode['file'],
                                        listitem=li,
                                        isFolder=False)

        count += 1
        if count >= limit:
            break

    xbmcplugin.endOfDirectory(handle=HANDLE)
Esempio n. 41
0
    def build_video_listing(self, video_list, actions, type, build_url):
        """Builds the video lists (my list, continue watching, etc.) contents Kodi screen

        Parameters
        ----------
        video_list_ids : :obj:`dict` of :obj:`str`
            List of video lists

        actions : :obj:`dict` of :obj:`str`
            Dictionary of actions to build subsequent routes

        type : :obj:`str`
            None or 'queue' f.e. when it´s a special video lists

        build_url : :obj:`fn`
            Function to build the subsequent routes

        Returns
        -------
        bool
            List could be build
        """
        for video_list_id in video_list:
            video = video_list[video_list_id]
            li = xbmcgui.ListItem(label=video['title'])
            # add some art to the item
            li = self._generate_art_info(entry=video, li=li)
            # it´s a show, so we need a subfolder & route (for seasons)
            isFolder = True
            url = build_url({
                'action': actions[video['type']],
                'show_id': video_list_id
            })
            # lists can be mixed with shows & movies, therefor we need to check if its a movie, so play it right away
            if video_list[video_list_id]['type'] == 'movie':
                # it´s a movie, so we need no subfolder & a route to play it
                isFolder = False
                url = build_url({
                    'action': 'play_video',
                    'video_id': video_list_id
                })
            # add list item info
            li = self._generate_entry_info(entry=video, li=li)
            li = self._generate_context_menu_items(entry=video, li=li)
            xbmcplugin.addDirectoryItem(handle=self.plugin_handle,
                                        url=url,
                                        listitem=li,
                                        isFolder=isFolder)

        xbmcplugin.addSortMethod(handle=self.plugin_handle,
                                 sortMethod=xbmcplugin.SORT_METHOD_LABEL)
        xbmcplugin.addSortMethod(handle=self.plugin_handle,
                                 sortMethod=xbmcplugin.SORT_METHOD_TITLE)
        xbmcplugin.addSortMethod(handle=self.plugin_handle,
                                 sortMethod=xbmcplugin.SORT_METHOD_VIDEO_YEAR)
        xbmcplugin.addSortMethod(handle=self.plugin_handle,
                                 sortMethod=xbmcplugin.SORT_METHOD_GENRE)
        xbmcplugin.addSortMethod(handle=self.plugin_handle,
                                 sortMethod=xbmcplugin.SORT_METHOD_LASTPLAYED)
        xbmcplugin.endOfDirectory(self.plugin_handle)
        return True
Esempio n. 42
0
def getInProgressEpisodes(tagname, limit):
    count = 0
    # if the addon is called with inprogressepisodes parameter,
    # we return the inprogressepisodes list of the given tagname
    xbmcplugin.setContent(HANDLE, 'episodes')
    # First we get a list of all the in-progress TV shows - filtered by tag
    params = {
        'sort': {
            'order': "descending",
            'method': "lastplayed"
        },
        'filter': {
            'and': [{
                'operator': "true",
                'field': "inprogress",
                'value': ""
            }, {
                'operator': "is",
                'field': "tag",
                'value': "%s" % tagname
            }]
        },
        'properties': ['title', 'studio', 'mpaa', 'file', 'art']
    }
    result = JSONRPC('VideoLibrary.GetTVShows').execute(params)
    # If we found any, find the oldest unwatched show for each one.
    try:
        items = result['result']['tvshows']
    except (KeyError, TypeError):
        pass
    else:
        for item in items:
            params = {
                'tvshowid':
                item['tvshowid'],
                'sort': {
                    'method': "episode"
                },
                'filter': {
                    'operator': "true",
                    'field': "inprogress",
                    'value': ""
                },
                'properties': [
                    "title", "playcount", "season", "episode", "showtitle",
                    "plot", "file", "rating", "resume", "tvshowid", "art",
                    "cast", "streamdetails", "firstaired", "runtime", "writer",
                    "dateadded", "lastplayed"
                ]
            }
            result = JSONRPC('VideoLibrary.GetEpisodes').execute(params)
            try:
                episodes = result['result']['episodes']
            except (KeyError, TypeError):
                pass
            else:
                for episode in episodes:
                    li = createListItem(episode)
                    xbmcplugin.addDirectoryItem(handle=HANDLE,
                                                url=episode['file'],
                                                listitem=li)
                    count += 1

            if count == limit:
                break

    xbmcplugin.endOfDirectory(handle=HANDLE)
Esempio n. 43
0
    def getCategoryItems(self, url, page):
        #print "*** Get category items %s" % url
        page_url = "%s/page/%s/" % (url, str(int(page)))
        response = common.fetchPage({"link": page_url})
        per_page = 0
        pagenav = None

        if response["status"] == 200:
            content = common.parseDOM(response["content"],
                                      "div",
                                      attrs={"id": "container"})
            items = common.parseDOM(content,
                                    "div",
                                    attrs={"class": "owl-item"})

            link_container = common.parseDOM(
                items, "h2", attrs={"class": "main-sliders-title"})
            titles = common.parseDOM(link_container, "a")
            links = common.parseDOM(link_container, "a", ret="href")
            images = common.parseDOM(items, "img", ret="src")

            descs = common.parseDOM(items, "i")
            pagenav = common.parseDOM(content,
                                      "div",
                                      attrs={"class": "navigation"})

            for i, title in enumerate(titles):
                per_page += 1
                title = self.strip(self.encode(title))

                image = images[(i + 1) * 3 - 1] if 'http' in images[
                    (i + 1) * 3 - 1] else self.url + images[(i + 1) * 3 - 1]

                genres_cont = common.parseDOM(items[i], "em")
                genres = common.parseDOM(genres_cont, "a")
                genre = self.encode(', '.join(genres))
                description = self.strip(self.encode(descs[i]))

                uri = sys.argv[0] + '?mode=show&url=%s' % (links[i])
                self.log("image: %s" % image)
                self.log("uri: %s" % uri)
                item = xbmcgui.ListItem(title,
                                        iconImage=image,
                                        thumbnailImage=image)
                item.setInfo(type='Video',
                             infoLabels={
                                 'title': title,
                                 'genre': genre,
                                 'plot': description
                             })

                xbmcplugin.addDirectoryItem(self.handle, uri, item, True)

        if pagenav and not per_page < 15:
            uri = sys.argv[0] + '?mode=%s&url=%s&page=%s' % (
                "category", url, str(int(page) + 1))
            item = xbmcgui.ListItem("[COLOR=orange]" + self.language(9000) +
                                    "[/COLOR]",
                                    thumbnailImage=self.inext,
                                    iconImage=self.inext)
            xbmcplugin.addDirectoryItem(self.handle, uri, item, True)

        xbmcplugin.setContent(self.handle, 'movies')
        xbmcplugin.endOfDirectory(self.handle, True)
Esempio n. 44
0
def addDirectoryItem(name, parameters={}, pic="DefaultVideoCover.png", lbl2=""):
    li = xbmcgui.ListItem(label=name, label2=lbl2, iconImage=pic, thumbnailImage=pic)
    url = sys.argv[0] + '?' + urllib.urlencode(parameters)
    return xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=li, isFolder=True)
Esempio n. 45
0
    def getFilmInfo_(self, url):
        print "*** getFilmInfo for url %s " % url
        response = common.fetchPage({"link": url})

        container = common.parseDOM(response["content"],
                                    "div",
                                    attrs={"id": "container"})
        js_container = common.parseDOM(response["content"],
                                       "div",
                                       attrs={"class": "section"})
        source2 = common.parseDOM(response["content"],
                                  "div",
                                  attrs={"id": "players"})[0]
        try:
            source = common.parseDOM(js_container,
                                     "script",
                                     attrs={"type": "text/javascript"})[6]
        except:
            source = source2

        title = self.encode(common.parseDOM(container, "h1")[0])
        image = common.parseDOM(container,
                                "img",
                                attrs={"id": "imgbigp"},
                                ret="src")[0]
        quality = common.parseDOM(container,
                                  "div",
                                  attrs={"class": "full-quality"})

        movie = source.split('file":"')[-1].split(
            '"};')[0] if 'file":"' in source else None
        if (not movie):
            movie = source2.split('file:"')[-1].split(
                '"')[0] if 'file:"' in source2 else None

        playlist = source.split(',pl:"')[-1].split(
            '"};')[0] if ',pl:"' in source else None
        playlist = playlist.split(
            '",')[0] if playlist and '",' in playlist else playlist

        labels = {
            'title': title,
            'genre': 'genres',
            'plot': 'description',
            'playCount': 0,
            'year': 1970,
            'rating': 0
        }

        if not playlist:
            links = movie.replace(' or ', ',').split(',') if (
                ',' or ' or ') in movie else [movie]
            image = image if 'http' in image else self.url + image
            format = quality[0] if quality else ''

            for i, link in enumerate(links):
                if ("]" in link):
                    link = link.split("]")[1]

                if '_720' in link:
                    quality = '720P'
                else:
                    quality = '480P'

                link_title = "%s [%s - %s]" % (title, quality, format)
                link_title = link_title.replace(
                    self.language(5002).encode('utf-8'),
                    '').replace('720 hd', '')

                uri = sys.argv[0] + '?mode=play&url=%s' % link
                item = xbmcgui.ListItem(link_title,
                                        iconImage=image,
                                        thumbnailImage=image)

                item.setInfo(type='Video', infoLabels={})
                item.setProperty('IsPlayable', 'true')
                xbmcplugin.addDirectoryItem(self.handle, uri, item, False)

            xbmcplugin.setContent(self.handle, 'files')

        else:
            headers = {
                "Host":
                self.domain,
                "Referer":
                url,
                "User-Agent":
                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36"
            }

            request = urllib2.Request(playlist, "", headers)
            request.get_method = lambda: 'GET'
            response = eval(urllib2.urlopen(request).read())

            if 'playlist' in response['playlist'][0]:
                print "This is a season multiple seasons"

                for season in response['playlist']:
                    episods = season['playlist']

                    for episode in episods:
                        etitle = episode['comment'].replace('<br>', '  ')
                        url = episode['file'].split(
                            ',')[-1] if '_720' in episode['file'] else episode[
                                'file'].split(',')[0]
                        uri = sys.argv[0] + '?mode=play&url=%s' % url
                        item = xbmcgui.ListItem(etitle.replace('<br>', '  '),
                                                iconImage=image,
                                                thumbnailImage=image)

                        item.setInfo(type='Video', infoLabels=labels)
                        item.setProperty('IsPlayable', 'true')
                        xbmcplugin.addDirectoryItem(self.handle, uri, item,
                                                    False)
            else:
                print "This is one season"
                for episode in response['playlist']:
                    try:
                        etitle = episode['comment']
                    except KeyError:
                        etitle = episode['commet']

                    url = episode['file'].split(',')[-1] if '_720' in episode[
                        'file'] else episode['file'].split(',')[0]
                    uri = sys.argv[0] + '?mode=play&url=%s' % url
                    item = xbmcgui.ListItem(etitle.replace('<br>', '  '),
                                            iconImage=image,
                                            thumbnailImage=image)

                    item.setInfo(type='Video', infoLabels=labels)
                    item.setProperty('IsPlayable', 'true')
                    xbmcplugin.addDirectoryItem(self.handle, uri, item, False)

            xbmcplugin.setContent(self.handle, 'episodes')

        xbmcplugin.endOfDirectory(self.handle, True)
Esempio n. 46
0
    def build_main_menu_listing(self, video_list_ids, user_list_order, actions,
                                build_url):
        """Builds the video lists (my list, continue watching, etc.) Kodi screen

        Parameters
        ----------
        video_list_ids : :obj:`dict` of :obj:`str`
            List of video lists

        user_list_order : :obj:`list` of :obj:`str`
            Ordered user lists, to determine what should be displayed in the main menue

        actions : :obj:`dict` of :obj:`str`
            Dictionary of actions to build subsequent routes

        build_url : :obj:`fn`
            Function to build the subsequent routes

        Returns
        -------
        bool
            List could be build
        """
        preselect_items = []
        for category in user_list_order:
            for video_list_id in video_list_ids['user']:
                if video_list_ids['user'][video_list_id]['name'] == category:
                    label = video_list_ids['user'][video_list_id][
                        'displayName']
                    if category == 'netflixOriginals':
                        label = label.capitalize()
                    li = xbmcgui.ListItem(label=label)
                    li.setProperty('fanart_image', self.default_fanart)
                    # determine action route
                    action = actions['default']
                    if category in actions.keys():
                        action = actions[category]
                    # determine if the item should be selected
                    preselect_items.append(
                        (False,
                         True)[category == self.get_main_menu_selection()])
                    url = build_url({
                        'action': action,
                        'video_list_id': video_list_id,
                        'type': category
                    })
                    xbmcplugin.addDirectoryItem(handle=self.plugin_handle,
                                                url=url,
                                                listitem=li,
                                                isFolder=True)

        # add recommendations/genres as subfolders (save us some space on the home page)
        i18n_ids = {
            'recommendations': self.get_local_string(30001),
            'genres': self.get_local_string(30010)
        }
        for type in i18n_ids.keys():
            # determine if the lists have contents
            if len(video_list_ids[type]) > 0:
                # determine action route
                action = actions['default']
                if type in actions.keys():
                    action = actions[type]
                # determine if the item should be selected
                preselect_items.append(
                    (False, True)[type == self.get_main_menu_selection()])
                li_rec = xbmcgui.ListItem(label=i18n_ids[type])
                li_rec.setProperty('fanart_image', self.default_fanart)
                url_rec = build_url({'action': action, 'type': type})
                xbmcplugin.addDirectoryItem(handle=self.plugin_handle,
                                            url=url_rec,
                                            listitem=li_rec,
                                            isFolder=True)

        # add search as subfolder
        action = actions['default']
        if 'search' in actions.keys():
            action = actions[type]
        li_rec = xbmcgui.ListItem(label=self.get_local_string(30011))
        li_rec.setProperty('fanart_image', self.default_fanart)
        url_rec = build_url({'action': action, 'type': 'search'})
        xbmcplugin.addDirectoryItem(handle=self.plugin_handle,
                                    url=url_rec,
                                    listitem=li_rec,
                                    isFolder=True)

        # no srting & close
        xbmcplugin.addSortMethod(handle=self.plugin_handle,
                                 sortMethod=xbmcplugin.SORT_METHOD_UNSORTED)
        xbmcplugin.endOfDirectory(self.plugin_handle)

        # (re)select the previously selected main menu entry
        idx = 1
        for item in preselect_items:
            idx += 1
            preselected_list_item = idx if item else None
        preselected_list_item = idx + 1 if self.get_main_menu_selection(
        ) == 'search' else preselected_list_item
        if preselected_list_item != None:
            xbmc.executebuiltin(
                'ActivateWindowAndFocus(%s, %s)' %
                (str(
                    xbmcgui.Window(xbmcgui.getCurrentWindowId()).getFocusId()),
                 str(preselected_list_item)))
        return True
Esempio n. 47
0
def add_item(handle, url, listitem, isFolder):
    xbmcplugin.addDirectoryItem(handle, url, listitem, isFolder)
Esempio n. 48
0
    def search(self, keyword, external):
        keyword = urllib.unquote_plus(keyword) if (
            external != None) else self.getUserInput()

        if keyword:
            # Advanced search: titles only
            values = {
                "beforeafter": "after",
                "catlist[]": 0,
                "do": "search",
                "full_search": 0,
                "replyless": 0,
                "replylimit": 0,
                "resorder": "desc",
                "result_from": 1,
                "search_start": 1,
                "searchdate": 0,
                "searchuser": "",
                "showposts": 0,
                "sortby": "date",
                "story": self.decode(keyword),
                "subaction": "search",
                "titleonly": 0
            }

            headers = {
                "User-Agent":
                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:35.0) Gecko/20100101 Firefox/35.0"
            }

            # Find redirected URL
            redirection = urllib2.Request(self.url, None, headers)
            url = urllib2.urlopen(redirection).geturl()

            # Send request to server
            request = urllib2.Request(url, urllib.urlencode(values), headers)
            response = urllib2.urlopen(request).read()

            content = common.parseDOM(response,
                                      "div",
                                      attrs={"id": "container"})
            items = common.parseDOM(content, "div", attrs={"class": "item"})

            link_container = common.parseDOM(
                items, "div", attrs={"class": "main-sliders-title"})
            titles = common.parseDOM(link_container, "a")
            links = common.parseDOM(link_container, "a", ret="href")
            images = common.parseDOM(items, "img", ret="src")

            descs = common.parseDOM(items, "i")

            for i, title in enumerate(titles):
                uri = sys.argv[0] + '?mode=show&url=%s' % links[i]
                image = images[i] if 'http' in images[
                    i] else self.url + images[i]
                item = xbmcgui.ListItem(self.encode(self.strip(title)),
                                        thumbnailImage=image)
                xbmcplugin.addDirectoryItem(self.handle, uri, item, True)

            xbmcplugin.setContent(self.handle, 'movies')
            xbmcplugin.endOfDirectory(self.handle, True)
        else:
            self.menu()
def PLAYLINK(name,url):
    ok=True
    liz=xbmcgui.ListItem(name, iconImage=icon,thumbnailImage=icon); liz.setInfo( type="Video", infoLabels={ "Title": name } )
    ok=xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=url,listitem=liz)
    xbmc.Player ().play(url, liz, False)
    return ok
Esempio n. 50
0
 def _fill_media_list( self, videos, page, pages=1, perpage=1, total=1 ):
     try:
         ok = True
         # calculate total items including dummy folders
         total_items = len( videos )
         # if there is more than one page and we're on page one, we create dummy folders for the other videos
         if ( page == 1 and pages > 1 ):
             # add our pages to the total items
             total_items += pages - 1
             # enumerate the pages
             for pageno in range( 2, pages + 1 ):
                 # calculate the starting video
                 startno = ( pageno - 1 ) * perpage + 1
                 # calculate the ending video
                 endno = pageno * perpage
                 # if there are fewer videos than per_page set endno to total
                 if ( endno > total ):
                     endno = total
                 # create the callback url
                 url = "%s?title=%s&category=%s&page=%d&query=%s" % ( sys.argv[ 0 ], repr( self.args.title ), repr( self.args.category ), pageno, repr( self.args.query ), )
                 # set the default icon
                 icon = "DefaultFolder.png"
                 # only need to add label and icon, setInfo() and addSortMethod() takes care of label2
                 listitem=xbmcgui.ListItem( label="%s (%d-%d)" % ( xbmc.getLocalizedString( 3 ), startno, endno, ), iconImage=icon )
                 # add the folder item to our media list
                 ok = xbmcplugin.addDirectoryItem( handle=int( sys.argv[ 1 ] ), url=url, listitem=listitem, isFolder=True, totalItems=total_items )
         # enumerate through the list of videos and add the item to the media list
         for video in videos:
             # only add videos with an embeddable video
             # TODO: Filter formats ?
             if ( video[ "FileFormat" ] ):
                 # create the title, we use video title and author
                 title = video[ "Title" ].replace( "\\/", "/" )
                 if ( title.startswith( "'" ) and title.endswith( "'" ) ):
                     title = title[ 1 : -1 ]
                 # thumbnail url
                 thumbnail_url = video[ "Thumbnail" ][ "Url" ].replace( "\\/", "/" )
                 # plot
                 plot = "no summary was furnished by user"
                 if ( video[ "Summary" ] ):
                     plot = video[ "Summary" ]
                 # format runtime as 00:00
                 try:
                     runtime = int( video[ "Duration" ] )
                 except:
                     runtime = ""
                 # video runtime
                 if ( runtime ):
                     runtime = "%02d:%02d" % ( int( runtime / 60 ), runtime % 60 )
                 # we use studio as the site specifier
                 if ( "yahoo" in video[ "ClickUrl" ] ): studio = "Yahoo"
                 elif ( ".aol." in video[ "ClickUrl" ] ): studio = "AOL"
                 elif ( "youtube" in video[ "ClickUrl" ] ): studio = "Youtube"
                 #elif ( "google" in video[ "ClickUrl" ] ): studio = "Google"
                 else: studio = "Other"
                 # construct our url
                 url = "%s?title=%s&url=%s&category='play_video'" % ( sys.argv[ 0 ], repr( title ), repr( video[ "ClickUrl" ].replace( "\\/", "/" ).replace( "&", "-*-*-" ) ), )
                 # set the default icon
                 icon = "DefaultVideo.png"
                 # only need to add label, icon and thumbnail, setInfo() and addSortMethod() takes care of label2
                 listitem=xbmcgui.ListItem( label=title, iconImage=icon, thumbnailImage=thumbnail_url )
                 # add the different infolabels we want to sort by
                 listitem.setInfo( type="Video", infoLabels={ "Title": title, "Duration": runtime, "Plot": plot, "PlotOutline": plot, "Studio": studio } )
                 # add the video to the media list
                 ok = xbmcplugin.addDirectoryItem( handle=int( sys.argv[ 1 ] ), url=url, listitem=listitem, isFolder=False, totalItems=total_items )
                 # if user cancels, call raise to exit loop
                 if ( not ok ): raise
     except:
         # oops print error message
         print "ERROR: %s::%s (%d) - %s" % ( self.__class__.__name__, sys.exc_info()[ 2 ].tb_frame.f_code.co_name, sys.exc_info()[ 2 ].tb_lineno, sys.exc_info()[ 1 ], )
         ok = False
     # if successful and user did not cancel, add all the required sort methods
     if ( ok ):
         xbmcplugin.addSortMethod( handle=int( sys.argv[ 1 ] ), sortMethod=xbmcplugin.SORT_METHOD_LABEL )
         xbmcplugin.addSortMethod( handle=int( sys.argv[ 1 ] ), sortMethod=xbmcplugin.SORT_METHOD_STUDIO )
         xbmcplugin.addSortMethod( handle=int( sys.argv[ 1 ] ), sortMethod=xbmcplugin.SORT_METHOD_VIDEO_RUNTIME )
     return ok, total_items
Esempio n. 51
0
def list_favourites_new(label):
    items = int(addon.getSetting("favourites_new_count"))
    xbmcplugin.setPluginCategory(_handle, label)
    favourites = get_favourites(others=0)
    episodes = {}
    episodes_ordered = {}
    for showId in favourites:
        show = favourites[showId]
        data = call_api(url="https://api.mujrozhlas.cz/shows/" + showId +
                        "/episodes?sort=-since&page[limit]=" + str(items))
        if "err" in data:
            xbmcgui.Dialog().notification(
                "ČRo", "Pořad " + show["title"] + " nebyl nalezený",
                xbmcgui.NOTIFICATION_ERROR, 4000)
            # sys.exit()
        if "data" in data and len(data["data"]) > 0:
            for episode in data["data"]:
                if "attributes" in episode and "title" in episode[
                        "attributes"] and len(
                            episode["attributes"]["title"]) > 0:
                    starttime = parse_date(episode["attributes"]["since"])
                    starttime_ts = time.mktime(starttime.timetuple())
                    episodes_ordered.update({episode["id"]: starttime_ts})
                    if "mirroredSerial" in episode[
                            "attributes"] and "totalParts" in episode[
                                "attributes"][
                                    "mirroredSerial"] and "part" in episode[
                                        "attributes"]:
                        parts = " (" + str(
                            episode["attributes"]["part"]) + "/" + str(
                                episode["attributes"]["mirroredSerial"]
                                ["totalParts"]) + ") "
                    else:
                        parts = ""
                    title = episode["attributes"][
                        "title"] + parts + " (" + starttime.strftime(
                            "%d.%m.%Y %H:%M") + ")"
                    link = episode["attributes"]["audioLinks"][0]["url"]
                    episodes.update({
                        episode["id"]: {
                            "showId": showId,
                            "link": link,
                            "img": show["img"],
                            "tvshowtitle": show["title"],
                            "title": title,
                            "aired": starttime.strftime("%Y-%m-%d"),
                            "director": [show["director"]],
                            "plot": show["description"],
                            "studio": show["station"]
                        }
                    })

    if len(episodes) > 0:
        for key in sorted(episodes_ordered,
                          key=episodes_ordered.get,
                          reverse=True):
            list_item = xbmcgui.ListItem(label=episodes[key]["title"])
            list_item.setArt({
                "thumb": episodes[key]["img"],
                "icon": episodes[key]["img"]
            })
            list_item.setInfo(
                "video", {
                    "tvshowtitle": episodes[key]["tvshowtitle"],
                    "title": episodes[key]["title"],
                    "aired": episodes[key]["aired"],
                    "director": episodes[key]["director"],
                    "plot": episodes[key]["plot"],
                    "studio": episodes[key]["studio"]
                })
            list_item.setProperty("IsPlayable", "true")
            list_item.setContentLookup(False)
            url = get_url(action='play',
                          url=encode(episodes[key]["link"]),
                          showId=episodes[key]["showId"],
                          episodeId=key,
                          title=encode(episodes[key]["title"]),
                          img=episodes[key]["img"])
            if PY2:
                xbmcplugin.addDirectoryItem(_handle, url, list_item, False)
            else:
                xbmcplugin.addDirectoryItem(_handle, url, list_item, True)
    xbmcplugin.endOfDirectory(_handle)
Esempio n. 52
0
    def add_item(self,
                 queries,
                 infolabels,
                 contextmenu_items='',
                 context_replace=False,
                 img='',
                 fanart='',
                 resolved=False,
                 total_items=0,
                 playlist=False,
                 item_type='video',
                 is_folder=False):
        '''
        Adds an item to the list of entries to be displayed in XBMC or to a 
        playlist.
        
        Use this method when you want users to be able to select this item to
        start playback of a media file. ``queries`` is a dict that will be sent 
        back to the addon when this item is selected::
        
            add_item({'host': 'youtube.com', 'media_id': 'ABC123XYZ'}, 
                     {'title': 'A youtube vid'})
                     
        will add a link to::
        
            plugin://your.plugin.id/?host=youtube.com&media_id=ABC123XYZ
        
        .. seealso::
        
            :meth:`add_music_item`, :meth:`add_video_item`, 
            :meth:`add_directory`
            
        Args:
            queries (dict): A set of keys/values to be sent to the addon when 
            the user selects this item.
            
            infolabels (dict): A dictionary of information about this media 
            (see the `XBMC Wiki InfoLabels entry 
            <http://wiki.xbmc.org/?title=InfoLabels>`_).
            
        Kwargs:
            
            contextmenu_items (list): A list of contextmenu items
            
            context_replace (bool): To replace the xbmc default contextmenu items
                    
            img (str): A URL to an image file to be used as an icon for this
            entry.
            
            fanart (str): A URL to a fanart image for this entry.
            
            resolved (str): If not empty, ``queries`` will be ignored and 
            instead the added item will be the exact contentes of ``resolved``.
            
            total_items (int): Total number of items to be added in this list.
            If supplied it enables XBMC to show a progress bar as the list of
            items is being built.
            
            playlist (playlist object): If ``False`` (default), the item will 
            be added to the list of entries to be displayed in this directory. 
            If a playlist object is passed (see :meth:`get_playlist`) then 
            the item will be added to the playlist instead

            item_type (str): The type of item to add (eg. 'music', 'video' or
            'pictures')
        '''
        infolabels = self.unescape_dict(infolabels)
        if not resolved:
            if not is_folder:
                queries['play'] = 'True'
            play = self.build_plugin_url(queries)
        else:
            play = resolved
        listitem = xbmcgui.ListItem(infolabels['title'])
        listitem.setInfo(item_type, infolabels)
        listitem.setProperty('IsPlayable', 'true')
        listitem.setProperty('fanart_image', fanart)
        try:
            listitem.setArt({'thumb': img})
        except:
            listitem.setThumbnailImage(img)
            self.log_debug('t0mm0-addon.py: setThumbnailImage is deprecated')

        if contextmenu_items:
            listitem.addContextMenuItems(contextmenu_items,
                                         replaceItems=context_replace)
        if playlist is not False:
            self.log_debug('adding item: %s - %s to playlist' % \
                                                    (infolabels['title'], play))
            playlist.add(play, listitem)
        else:
            self.log_debug('adding item: %s - %s' %
                           (infolabels['title'], play))
            xbmcplugin.addDirectoryItem(self.handle,
                                        play,
                                        listitem,
                                        isFolder=is_folder,
                                        totalItems=total_items)
Esempio n. 53
0
def addDir(url, title, icon, fanart):
    li = xbmcgui.ListItem(title, iconImage=icon)
    li.setProperty("Fanart_Image", fanart)
    xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li)
Esempio n. 54
0
def list_favourites(label, others=0):
    xbmcplugin.setPluginCategory(_handle, label)
    favourites = get_favourites(int(others))
    favourites_ordered = {}

    for key in favourites:
        favourites_ordered.update({key: favourites[key]["title"]})
    for showId in sorted(favourites_ordered, key=favourites_ordered.get):
        show = favourites[showId]
        if addon.getSetting(
                "hide_unlistened_favourites") == "false" and others == 0:
            unlistened = get_unlistened_count(showId)
            if unlistened > 0:
                list_item = xbmcgui.ListItem(label=show["title"] + " (" +
                                             str(unlistened) +
                                             decode(" nových)"))
            elif unlistened == 0:
                list_item = xbmcgui.ListItem(label=show["title"])
            else:
                list_item = xbmcgui.ListItem(label=show["title"] +
                                             ' (nenalezený pořad)')
        else:
            list_item = xbmcgui.ListItem(label=show["title"])
        list_item.setArt({"thumb": show["img"], "icon": show["img"]})
        list_item.setInfo(
            "video", {
                "title": show["title"],
                "director": [show["director"]],
                "plot": show["description"],
                "studio": show["station"]
            })
        if len(show["cast"]) > 0:
            list_item.setInfo("video", {"cast": show["cast"]})

        menus = [(
            "Odstranit z oblíbených",
            "RunPlugin(plugin://plugin.audio.cro?action=delete_favourites&showId="
            + str(show["id"]) + ")")]
        if others == 0:
            menus.append((
                "Přesunout do ostatních",
                "RunPlugin(plugin://plugin.audio.cro?action=set_others&showId="
                + str(show["id"]) + "&val=1" + ")"))
        else:
            menus.append((
                "Přesunout z ostatních",
                "RunPlugin(plugin://plugin.audio.cro?action=set_others&showId="
                + str(show["id"]) + "&val=0" + ")"))
        if addon.getSetting(
                "hide_unlistened_favourites") == "false" and others == 0:
            menus.append((
                "Označit epizody jako poslechnuté",
                "RunPlugin(plugin://plugin.audio.cro?action=set_listened_all&showId="
                + str(show["id"]) + ")"))
        list_item.addContextMenuItems(menus)
        if addon.getSetting(
                "hide_unlistened_favourites") == "false" and others == 0:
            url = get_url(action='list_show',
                          showId=show["id"],
                          page=1,
                          label=encode(show["title"]),
                          mark_new=1)
        else:
            url = get_url(action='list_show',
                          showId=show["id"],
                          page=1,
                          label=encode(show["title"]),
                          mark_new=0)
        list_item.setContentLookup(False)
        xbmcplugin.addDirectoryItem(_handle, url, list_item, True)
    xbmcplugin.endOfDirectory(_handle, cacheToDisc=False)
Esempio n. 55
0
            TvdbApi.getFromDict(data, ['Details', 'writers'], ''))
        meta['director'] = ', '.join(
            TvdbApi.getFromDict(data, ['Details', 'directors'], ''))
        meta['studio'] = TvdbApi.getFromDict(data, ['Show', 'network'], '')
        meta['mpaa'] = TvdbApi.getFromDict(data, ['Show', 'rating'], '')
        meta['episode_id'] = TvdbApi.getFromDict(data, ['Details', 'id'], '')
        meta['year'] = TvdbApi.getFromDict(data, ['Show', 'firstAired'],
                                           '')[:4]
        meta['status'] = TvdbApi.getFromDict(data, ['Show', 'status'], '')
        #meta['cast'] = []
        #actors = [{'name': 'Tom Cruise', 'role': 'Himself', 'thumbnail': ''}, {'name': 'Actor 2', 'role': 'role 2'}]
        actors = data.get('Actors', [])
        actors = TvdbApi.CacheActorImages(actors, cache.actor_cache_dir)
        for value in TvdbApi.getFromDict(data, ['Details', 'guestStars'], ''):
            actors.append(dict({'name': value, 'role': 'Guest Star'}))
        if actors:
            list_item.setCast(actors)
    except:
        meta['tvdb_id'] = str(tvdbid)
        meta['tvshowtitle'] = show_name
        meta['title'] = name
        meta['season'] = int(season)
        meta['episode'] = int(episode)
    list_item.setInfo(type="Video", infoLabels=meta)
    list_item.addContextMenuItems(context_items, replaceItems=True)
    xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),
                                url=return_url,
                                listitem=list_item,
                                isFolder=False,
                                totalItems=total_items)
Esempio n. 56
0
        item['title'] = normalizeString(xbmc.getInfoLabel(
            "VideoPlayer.Title"))  # no original title, get just Title

    if item['episode'].lower().find("s") > -1:  # Check if season is "Special"
        item['season'] = "0"  #
        item['episode'] = item['episode'][-1:]

    if item['file_original_path'].find("http") > -1:
        item['temp'] = True

    elif item['file_original_path'].find("rar://") > -1:
        item['rar'] = True
        item['file_original_path'] = os.path.dirname(
            item['file_original_path'][6:])

    elif item['file_original_path'].find("stack://") > -1:
        stackPath = item['file_original_path'].split(" , ")
        item['file_original_path'] = stackPath[0][8:]

    Search(item)

elif params['action'] == 'download':
    subs = download(params["link"])
    for sub in subs:
        listitem = xbmcgui.ListItem(label=sub)
        xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),
                                    url=sub,
                                    listitem=listitem,
                                    isFolder=False)

xbmcplugin.endOfDirectory(int(sys.argv[1]))  # send end of directory to XBMC
Esempio n. 57
0
def Serch(url, title=""):
    http = getURL(url)
    #ss="<li class = 'playlist'>"
    #es="Setup the player to autoplay"
    #cut1='		|'+mfindal(http, ss, es)[0].replace("'#' data-src=", "")
    #http=http.replace("<li class='playlist'>","<li class = 'playlist'>")
    ss = "<li class = 'playlist'>"
    es = '</a><hr/></li>'
    L1 = mfindal(http, ss, es)
    fl = 0
    if len(L1) == 0:
        ss = "<li class='playlist'>"
        es = '</a></li></ol>'
        L1 = mfindal(http, ss, es)
        fl = 1

    for i in L1:
        ss = 'http://d.mds-fm.ru'
        es = '.mp3">'
        L2 = mfindal(i, ss, es)

        ss = '.mp3">'
        es = '</a>'
        try:
            title = mfindal(i, ss, es)[0][len(ss):]
        except:
            pass

        ss = '</a><p>'
        es = '</p></li>'
        try:
            plot = mfindal(i, ss, es)[0][len(ss):]
        except:
            plot = ""

        if len(L2) > 1:
            k = 0
            for j in L2:
                k += 1
                url = j + ".mp3"
                img = thumb
                title2 = Format(title) + " ч. " + str(k)
                item = xbmcgui.ListItem(title2,
                                        iconImage=img,
                                        thumbnailImage=img)
                item.setInfo(type="music",
                             infoLabels={
                                 "Title": title.replace(".", "\n"),
                                 "Comment": plot,
                                 "album": plot
                             })
                item.setProperty('IsPlayable', 'true')
                xbmcplugin.addDirectoryItem(pluginhandle, url, item, False)
        else:
            url = L2[0] + ".mp3"
            img = thumb
            item = xbmcgui.ListItem(Format(title),
                                    iconImage=img,
                                    thumbnailImage=img)
            item.setInfo(type="music",
                         infoLabels={
                             "Title": title.replace(".", "\n"),
                             "album": plot,
                             "Comment": plot
                         })
            item.setProperty('IsPlayable', 'true')
            xbmcplugin.addDirectoryItem(pluginhandle, url, item, False)

    if fl == 1 and len(L2) == 1: xbmc.Player().play(url)
    else: xbmcplugin.endOfDirectory(pluginhandle)
Esempio n. 58
0
    my_stations = readFile(mystations_path)
else:
    writeFile(mystations_path, my_stations)

mode = args.get('mode', None)

if mode is None:
    localUrl = build_url({
        'mode':
        'stations',
        'url':
        'http://www.radio-browser.info/webservice/json/stations/topclick/100'
    })
    li = xbmcgui.ListItem(LANGUAGE(32000), iconImage='DefaultFolder.png')
    xbmcplugin.addDirectoryItem(handle=addon_handle,
                                url=localUrl,
                                listitem=li,
                                isFolder=True)

    localUrl = build_url({
        'mode':
        'stations',
        'url':
        'http://www.radio-browser.info/webservice/json/stations/topvote/100'
    })
    li = xbmcgui.ListItem(LANGUAGE(32001), iconImage='DefaultFolder.png')
    xbmcplugin.addDirectoryItem(handle=addon_handle,
                                url=localUrl,
                                listitem=li,
                                isFolder=True)

    localUrl = build_url({
Esempio n. 59
0
def readFolder(params):
    print params
    http = GET(params['href'])
    beautifulSoup = BeautifulSoup(http)
    content = beautifulSoup.findAll('div', attrs={'class': 'quote'})
    try:
        pist=content[0]
    except: pist=None
    z=None
    try: img='http://serialonline.net%s'%re.findall('left--><img src="(.+)" align="left" alt=',http)[0]
    except: 
        img=""
    if pist:
        dist=pist.findAll('a')
        for n in dist:
        #print n
        #print str(n.find('b')).replace('<b>','').replace('</b>','')
            li = xbmcgui.ListItem(str(n.find('b')).replace('<b>','').replace('</b>',''), img, img)
            uri = construct_request({
                'href': n['href'],
                'func': 'readFolder'
            })
            #print n['href']
            xbmcplugin.addDirectoryItem(hos, uri, li, True)
            z=True
    header=re.findall('<h1>[^/]+</h1>',http)[0].replace('</h1>','').replace('<h1>','').decode('cp1251').encode('utf-8')
    header='[COLOR FF00FF00]%s:[/COLOR]'%header
    
    if z:
        li = xbmcgui.ListItem(' ', addon_fanart, addon_icon)
        uri = construct_request({
            'filr': None
        })
        xbmcplugin.addDirectoryItem(hos, uri, li, False)
    
    li = xbmcgui.ListItem(header, addon_fanart, addon_icon)
    uri = construct_request({
        'filr': None
    })
    xbmcplugin.addDirectoryItem(hos, uri, li, False)

        # need to find flashvars="pl=http://serialonline.net/pl/810f6cc0b9e3e3cdd9c8557d09ac0ac2/beskontrolnye_1.txt&config=http://s
    playlist=re.findall('http://serialonline.net/pl/[0-9a-z]+/[^/]+.txt',http)
    if playlist==[]: playlist=re.findall('http://cdn.serialonline.net/pl/[0-9a-z]+/[^/]+.txt',http)
    fplaylist= playlist[0]
    files= GET(fplaylist)
    #print files
    flist=json.loads(files)
    #style="display:inline;"><!--dle_image_begin:(.+?)|left-->
    
    for index in flist['playlist']:
        li = xbmcgui.ListItem(index['comment'], img, img)
        li.setProperty('IsPlayable', 'true')
        uri = construct_request({
            'url': index['file'],
            'func': 'play'
        })
        
        xbmcplugin.addDirectoryItem(hos, uri, li, False)
    #li = xbmcgui.ListItem(playlist[0].split['='][1], addon_fanart, addon_icon)
    #uri = construct_request({
    #	'func': 'readFolder'
    #})
            #print n['href']
    #xbmcplugin.addDirectoryItem(hos, uri, li, True)
    xbmcplugin.setContent(hos, 'movies')
    xbmcplugin.endOfDirectory(hos)
Esempio n. 60
0
def Root():
    title = "Поиск"
    url = ""
    img = thumb
    uri = sys.argv[0] + '?mode=title'
    uri += '&url=' + urllib.quote_plus(url)
    uri += '&name=' + urllib.quote_plus(title)
    uri += '&img=' + urllib.quote_plus(img)
    item = xbmcgui.ListItem(title, iconImage=img, thumbnailImage=img)
    item.setInfo(type="Music", infoLabels={"Title": title})
    xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)

    title = "Автор"
    url = ""
    img = thumb
    uri = sys.argv[0] + '?mode=author'
    uri += '&url=' + urllib.quote_plus(url)
    uri += '&name=' + urllib.quote_plus(title)
    uri += '&img=' + urllib.quote_plus(img)
    item = xbmcgui.ListItem(title, iconImage=img, thumbnailImage=img)
    item.setInfo(type="Music", infoLabels={"Title": title})
    #xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)

    title = "Жанры"
    url = ""
    img = thumb
    uri = sys.argv[0] + '?mode=genres'
    uri += '&url=' + urllib.quote_plus(url)
    uri += '&name=' + urllib.quote_plus(title)
    uri += '&img=' + urllib.quote_plus(img)
    item = xbmcgui.ListItem(title, iconImage=img, thumbnailImage=img)
    item.setInfo(type="Music", infoLabels={"Title": title})
    xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)

    title = "Сюжетные ходы"
    url = ""
    img = thumb
    uri = sys.argv[0] + '?mode=plot'
    uri += '&url=' + urllib.quote_plus(url)
    uri += '&name=' + urllib.quote_plus(title)
    uri += '&img=' + urllib.quote_plus(img)
    item = xbmcgui.ListItem(title, iconImage=img, thumbnailImage=img)
    item.setInfo(type="Music", infoLabels={"Title": title})
    xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)

    title = "Место действия"
    url = ""
    img = thumb
    uri = sys.argv[0] + '?mode=scene'
    uri += '&url=' + urllib.quote_plus(url)
    uri += '&name=' + urllib.quote_plus(title)
    uri += '&img=' + urllib.quote_plus(img)
    item = xbmcgui.ListItem(title, iconImage=img, thumbnailImage=img)
    item.setInfo(type="Music", infoLabels={"Title": title})
    xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)

    title = "Время действия"
    url = ""
    img = thumb
    uri = sys.argv[0] + '?mode=time'
    uri += '&url=' + urllib.quote_plus(url)
    uri += '&name=' + urllib.quote_plus(title)
    uri += '&img=' + urllib.quote_plus(img)
    item = xbmcgui.ListItem(title, iconImage=img, thumbnailImage=img)
    item.setInfo(type="Music", infoLabels={"Title": title})
    xbmcplugin.addDirectoryItem(pluginhandle, uri, item, True)

    xbmcplugin.endOfDirectory(pluginhandle)