def highlights(): href = get_arg("href", False) xp.setPluginCategory(plugin.handle, get_arg("title", ku.get_string(32006))) # Highlights if not href: url = eafa.get_page_url("highlights.aspx") data = eafa.get_html(url) for item in data.find_all("div", "hl_box"): action = item.find("a") img = action.find("img") title = img["alt"] add_menu_item( highlights, title, {"href": action["href"], "title": title}, art=ku.art(eafa.get_page_url(img["src"])) ) xp.setContent(plugin.handle, "videos") xp.endOfDirectory(plugin.handle) return url = eafa.get_page_url(href) data = eafa.get_html(url) form = get_form_data(data) if form: parse_links(data, form) else: parse_results(data)
def section(): # type: () -> None """Handles the various sections such as years, genre, series, etc""" href = get_arg("href", False) token = get_arg("token", False) category = get_arg("category") if not href and token: # Section menu soup = mias.get_html(mias.get_search_url()) element = soup.find("ul", {"id": token}) if not element: logger.debug("No menu data: {}".format(token)) return items = element.extract().findAll("li") for item in items: action = item.find("a") if not action: continue title = action.text.title() add_menu_item(section, title, args={ "href": action["href"], "category": title }) else: # Section playable items url = mias.get_url(href) soup = mias.get_html(url) parse_search_results(soup, url, category) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def experts(): """Lists experts, and their choices""" href = get_arg("href", False) if not href: url = jafc.get_url("en/works-favorites.html") data = jafc.get_html(url) container = data.find("div", "work-favorites") for item in container.find_all("div", "work-favorite"): author = item.find("strong").text add_menu_item(experts, author, args={"href": "en/" + item.find("a")["href"], "title": item.find("strong").text}, info={"plot": item.find("div", "work-favorite-summary").text}, art=ku.art(jafc.get_url(item.find("img", "thumbnail")["src"]))) xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32023)) # Experts Choice else: url = jafc.get_url(href) data = jafc.get_html(url) for item in data.find_all("div", "favorite-work"): action = item.find("h2").find("a") add_menu_item(play_film, action.text, args={"href": action["href"]}, info={"plot": item.find("dd").text}, art=ku.art(jafc.get_url(item.find("img", "thumbnail")["src"])), directory=False) xbmcplugin.setPluginCategory(plugin.handle, get_arg("title")) # Experts name xbmcplugin.endOfDirectory(plugin.handle)
def programme(): """Shows the programme menu or a programme's playable items""" href = get_arg("href") category = get_arg("category", ku.localize(32009)) # Programs if not href: # TV Shows menu soup = dws.get_html(dws.DW_PROGRAMME_URI) content = soup.find("div", {"id": "bodyContent"}).extract() items = content.find_all("div", "epg") for item in items: img = item.find("img") title = item.find("h2").text.encode("utf-8") action = item.find("a", string="All videos") pid = dws.get_program_id(action.get("href")) plot = item.find("p").text.strip() add_menu_item(programme, title, { "href": dws.get_search_url(pid=pid), "category": title }, ku.art(dws.get_url(img.get("src"))), {"plot": plot if plot else title}) xbmcplugin.setContent(plugin.handle, "tvshows") else: # TV Show's playable episodes soup = dws.get_html(href) parse_search_results(soup, href, programme, category) xbmcplugin.setContent(plugin.handle, "episodes") xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def experts(): """Lists experts, and their choices""" href = get_arg("href", False) if not href: url = jafc.get_page_url("en/works-favorites.html") data = jafc.get_html(url) container = data.find("div", "work-favorites") for item in container.find_all("div", "work-favorite"): action = item.find("a") img = item.find("img", "thumbnail") title = img["alt"] ku.log(action) add_menu_item(experts, title, args={"href": "en/" + action["href"], "title": title}, info={"plot": item.find("div", "work-favorite-summary").text}, art=ku.art(jafc.get_page_url(img["src"]))) else: url = jafc.get_page_url(href) data = jafc.get_html(url) for item in data.find_all("div", "favorite-work"): img = item.find("img", "thumbnail") action = item.find("h2").find("a") title = action.text add_menu_item(play_film, title, args={"href": action["href"]}, info={"plot": item.find("dd").text}, art=ku.art(jafc.get_page_url(img["src"])), directory=False) xp.setPluginCategory(plugin.handle, get_arg("title")) xp.endOfDirectory(plugin.handle)
def section(): # type: () -> None """Show category menu and category playable items""" href = get_arg("href") category = get_arg("category", ku.localize(32002)) page = int(get_arg("page", 1)) offset = int(get_arg("offset", 0)) if not href: # section menu soup = nfpfs.get_html(nfpfs.NFPF_SCREENING_ROOM_URI) for item in soup.find_all("table"): title = item.find("h5").text add_menu_item(section, title, args={ "href": item.find("a").get("href"), "category": title }, art=ku.art(nfpfs.get_url( item.find("img").get("src"))), info={"plot": item.find("p").text}) else: url = nfpfs.get_url(href) soup = nfpfs.get_html(url) if url == nfpfs.NFPF_MERCURY_URI: # odd playable items parse_mercury(soup) else: results = soup.find_all("figure", "video-thumb") items = results[offset:nfpfs.SEARCH_MAX_RESULTS + offset] # section paging if len(results) > len(items) == nfpfs.SEARCH_MAX_RESULTS: paginate(category, href, page) for item in items: # section playable items action = item.find("figcaption").find("a") url = nfpfs.get_url(action.get("href")) data = nfpfs.get_info(nfpfs.get_html(url)) data.get("info")["genre"] = item.get("data-archive") add_menu_item(play_film, data.get("title"), args={"href": url}, art=ku.art(data.get("image")), info=data.get("info"), directory=False) xbmcplugin.setContent(plugin.handle, "videos") xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL_IGNORE_THE) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_VIDEO_YEAR) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_GENRE) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def programmes(): # type: () -> None """View series curated by British Pathé.""" href = get_arg("href", False) category = get_arg("category", ku.localize(32021)) # programming if not href: # Programmes menu soup = bps.get_html(bps.BP_COLLECTIONS_URI) for img in soup.select("a > img"): if img.parent['href'].startswith('/programmes/'): title = img.parent.findNext("a").text href = img.parent.findNext("a")["href"] add_menu_item(programmes, title, info={"plot": "foobar"}, args={ "href": href, "category": title }, art=ku.art(bps.get_uri(img["src"]))) else: # Programme's playable items soup = bps.get_html(bps.get_uri(href)) table = soup.find("table", {"id": "programmeTable"}).extract() for img in table.select("a > img"): action = img.parent row = action.find_parent("tr") add_menu_item(play_film, row.find("span").text, args={"href": action["href"]}, info={ "plot": "", "year": int(row.find("td", "far-right").text.strip()), "episode": int( row.find("td", "episode-number").text.strip()) }, art=ku.art(img["src"]), directory=False) xbmcplugin.setContent(plugin.handle, "episodes") xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL_IGNORE_THE) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_VIDEO_YEAR) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def the_cut(): # type: () -> None """Shows the-cut menu and sub-menu items""" href = get_arg("href") category = get_arg("title", "The Cut") if not href: # The Cut menu soup = bfis.get_html(bfis.THE_CUT_URI) for card in soup.find_all("div", "c_card"): action = card.find(["a", "card__action"]).extract() if action is None: continue title_tag = card.find("h3", "c_card__title") plot_tag = card.find("div", "c_card__footer__summary") title = title_tag.text if title_tag else action["aria-label"] add_menu_item(the_cut, title, args={ "href": action["href"], "title": title }, info={"plot": plot_tag.text}, art=ku.art(bfis.BFI_URI, card.find("img").attrs)) else: # The Cut playable items soup = bfis.get_html(bfis.get_page_url(href)) items = soup.find_all("div", "player") for item in items: plot = soup.find("div", "text__visible").find("p") \ if item is items[0] \ else item.find_next("div", "m_card__description") add_menu_item(play_film, item.get("data-label"), args={ "video_id": item.get(PLAYER_ID_ATTR), "href": href }, info={ "mediatype": "video", "plot": plot.text.encode("utf-8") if plot else "" }, art=ku.art(bfis.BFI_URI, item.find_next("img").attrs), directory=False) xbmcplugin.setContent(plugin.handle, "videos") xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def recent(): # type: () -> None """Show recently viewed films""" data = bfis.recents.retrieve() for url, video_id in data: soup = bfis.get_html(url) title = soup.find("h1").text.strip() description = soup.find("meta", { "name": "description" }).get("content").encode("utf-8") image = soup.find("meta", {"property": "og:image"}).get("content") add_menu_item(play_film, title, args={ "href": url, "video_id": video_id }, info={ "plot": description, "mediatype": "video" }, art=ku.art("", image), directory=False) xbmcplugin.setContent(plugin.handle, "videos") xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32021)) # Recently Viewed xbmcplugin.endOfDirectory(plugin.handle)
def archive(): # type: () -> None """View important anniversaries, contextualising current events or illustrating trending topics""" data = bps.get_html(bps.BP_ARCHIVE_URI) content = data.find("div", "entry-content") if not content: logger.debug("Missing menu: {}".format(bps.BP_ARCHIVE_URI)) return images = content.select("a > img") # Archive menu for img in images: action = img.findNext("a") if not action: continue title = action.text.strip() date = action.findNextSibling("strong").text.strip() add_menu_item(collection, "{} ({})".format(title, date), args={ "href": action["href"], "playable": True, "category": title }, art=ku.art(img["src"])) xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32009)) # Archive Picks xbmcplugin.endOfDirectory(plugin.handle)
def search(): query = get_arg("q") offset = int(get_arg("offset", 0)) # remove saved search item if bool(get_arg("delete", False)): bcfs.remove(query) xbmc.executebuiltin("Container.Refresh()") return True # View saved search menu if bool(get_arg("menu", False)): add_menu_item(search, "[{}]".format(ku.get_string(32016)), {"new": True}) # [New Search] for item in bcfs.retrieve(): text = item.encode("utf-8") add_menu_item(search, text, {"q": text}) xp.setPluginCategory(plugin.handle, ku.get_string(32007)) # Search xp.endOfDirectory(plugin.handle) return True # look-up if bool(get_arg("new", False)): query = ku.user_input() bcfs.append(query) if not query: return False search_url = bcfs.get_search_url(query=query) data = bcfs.get_html(search_url) xp.setPluginCategory( plugin.handle, "{} '{}'".format(ku.get_string(32007), bcfs.query_decode(query))) parse_results(data)
def films(): """Playable movie items""" url = jafc.get_url(get_arg("href")) data = jafc.get_html(url) paginate(data.find("ul", "pager-menu"), films) container = data.find(True, {"class": ["categories", "characters", "writer-works"]}) if container is None: ku.notification(ku.localize(32008), ku.localize(32009)) # Error - No playable items found return for item in container.find_all("li"): action = item.find("a") if action is None: continue add_menu_item( play_film, item.find(True, {"class": ["category-title", "character-serif", "writer-work-heading"]}).text, args={"href": action["href"]}, info=jafc.get_info(action["href"]), art=ku.art(jafc.get_url(item.find("img", "thumbnail")["src"])), directory=False) xbmcplugin.setContent(plugin.handle, "videos") xbmcplugin.setPluginCategory(plugin.handle, get_arg("title")) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL_IGNORE_THE) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_GENRE) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_VIDEO_YEAR) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_DURATION) xbmcplugin.endOfDirectory(plugin.handle)
def shows(): page = get_arg("page", 0) category = get_arg("category", ku.localize(32003)) soup = ngs.get_html(ngs.get_show_url(page)) # Shows paging load_more = soup.find("a", "load-more") if load_more: next_page = ngs.get_gp(load_more.get("href")) add_menu_item(shows, "[{} {}]".format(ku.localize(32011), next_page + 1), args={"page": next_page}) for item in soup.find_all("div", "media-module"): # shows menu action = item.find("a") title = item.find("div", "title").text img = action.find("img") count = ngs.get_playable_item_count(action.get("href")) add_menu_item(section, "{} [{} items]".format(title, count), args={ "href": action.get("href"), "category": title }, art=ku.art(img.get("src"))) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def films(): """Playable movie items""" url = jafc.get_page_url(get_arg("href")) data = jafc.get_html(url) paginate(data.find("ul", "pager-menu"), films) container = data.find(True, {"class": ["categories", "characters", "writer-works"]}) for item in container.find_all("li"): title = item.find(True, {"class": ["category-title", "character-serif", "writer-work-heading"]}).text action = item.find("a") if action is None: continue img = item.find("img", "thumbnail") add_menu_item( play_film, title, {"href": action["href"]}, info=get_info(action["href"]), art=ku.art(jafc.get_page_url(img["src"])), directory=False) xp.setPluginCategory(plugin.handle, get_arg("title")) xp.setContent(plugin.handle, "videos") xp.addSortMethod(plugin.handle, xp.SORT_METHOD_LABEL_IGNORE_THE) xp.addSortMethod(plugin.handle, xp.SORT_METHOD_GENRE) xp.addSortMethod(plugin.handle, xp.SORT_METHOD_VIDEO_YEAR) xp.addSortMethod(plugin.handle, xp.SORT_METHOD_DURATION) xp.endOfDirectory(plugin.handle)
def search(): # type: () -> Optional[bool] """Search the archive""" query = get_arg("q") category = get_arg("category", ku.localize(32007)) # Search total = get_arg("total") # Remove saved search item if bool(get_arg("delete", False)): pas.searches.remove(query) xbmc.executebuiltin("Container.Refresh()") return True # View saved search menu if bool(get_arg("menu", False)): add_menu_item(search, "[{}]".format(ku.localize(32016)), args={"new": True}) # [New Search] for item in pas.searches.retrieve(): text = item.encode("utf-8") add_menu_item(search, text, args={"q": text, "category": "{} '{}'".format(ku.localize(32007), text)}) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle) return True # New look-up if bool(get_arg("new", False)): query = ku.user_input() if not query: return False category = "{} '{}'".format(ku.localize(32007), query) if pas.SEARCH_SAVED: pas.searches.append(query) # Process search url = get_arg("href", pas.get_search_url(query=query)) soup = pas.get_html(url) count = int(total) if total else pas.text_to_int(soup.find("div", "results_count").text) parse_search_results(soup, url, count, category) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def browse(): data = eafa.get_html(eafa.EAFA_BROWSE_URI) form = get_form_data(data) if not form: return False container = data.find("div", {"id": get_arg("id")}) form["action"] = "browse.aspx" parse_links(container, form)
def collection(): # type: () -> None """Various workspaces by theme, location and the personalities involved.""" category = get_arg("category", False) playable = get_arg("playable", False) href = get_arg("href", False) data = bps.get_collection_data() if not category: # Main collections menu for item in data: add_menu_item(collection, item, args={"category": item.encode("utf-8")}) if category and not href: # Collection category menu for item in data[category]: add_menu_item(collection, item, args={ "href": bps.get_uri(data[category][item][0]), "category": item.encode("utf-8") }, art=ku.art(bps.get_uri(data[category][item][1]))) if href and not playable: # Collection category sub-meu soup = bps.get_html(href) workspaces = soup.find_all("dl", "workspace") for item in workspaces: action = item.find("a") title = action["title"].strip().encode("utf-8") add_menu_item(collection, title, args={ "href": action["href"], "category": title, "playable": True }, art=ku.art(item.find("img")["src"])) if href and playable: # Collection category sub-menu playable items soup = bps.get_html(href) parse_search_results(soup) xbmcplugin.setPluginCategory(plugin.handle, category if category else ku.localize(32004)) xbmcplugin.endOfDirectory(plugin.handle)
def past24h(): """Shows playable items from the last 24 hours""" url = dws.get_search_url() soup = dws.get_html(url) parse_search_results(soup, url, past24h, ku.localize(32004)) xbmcplugin.setContent(plugin.handle, "episodes") xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32004)) # Past 24 hours xbmcplugin.endOfDirectory(plugin.handle)
def year(token): if token == "0": for item in BCF_YEARS: add_menu_item(year, str(item), {"token": item}) xp.setPluginCategory(plugin.handle, ku.get_string(32005)) xp.endOfDirectory(plugin.handle) return uri = bcfs.get_search_url(year=token) data = bcfs.get_html(uri) xp.setPluginCategory(plugin.handle, token) parse_results(data)
def new(): # type: () -> None """Shows new playable items menu""" href = get_arg("href", ngs.NG_URI) soup = ngs.get_html(ngs.get_url(href)) parse_search_results( soup.find("div", { "id": "grid-frame" }).extract(), ku.localize(32006), new) xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32006)) xbmcplugin.endOfDirectory(plugin.handle)
def get_info(href): idx = jafc.text_to_int(href) data = jafc.get_html("{}{}".format(jafc.JAFC_INFO_URI, idx)) return { "plot": jafc.get_table_data(data, "Plot"), "title": jafc.get_table_data(data, "English Title"), "originaltitle": jafc.get_table_data(data, "Japanese kana Rendering"), # Original Title "year": jafc.text_to_int(jafc.get_table_data(data, "Production Date")), "director": jafc.get_table_data(data, "Credits: Director"), "duration": jafc.text_to_int(jafc.get_table_data(data, "Duration (minutes)")) * 60 }
def play_film(): """Attempts to find and load an m3u8 file for a give href""" url = bfis.get_page_url(get_arg("href")) html = bfis.get_html(url) try: video_id = html.find(True, attrs={PLAYER_ID_ATTR: True})[PLAYER_ID_ATTR] except (AttributeError, TypeError) as e: return False if video_id is not None: video_url = bfis.get_video_url(video_id) m3u8_url = bfis.get_m3u8(video_url) xp.setResolvedUrl(plugin.handle, True, ListItem(path=m3u8_url))
def series(token): if token == "0": for idx, name in enumerate(BCF_SERIES): if idx == 0: continue add_menu_item(series, name, {"token": idx}) xp.setPluginCategory(plugin.handle, ku.get_string(32006)) xp.endOfDirectory(plugin.handle) return uri = bcfs.get_search_url(series=token) data = bcfs.get_html(uri) xp.setPluginCategory(plugin.handle, BCF_SERIES[int(token)]) parse_results(data)
def topic(): """Shows the topics menu or a topic's playable items""" href = get_arg("href", False) category = get_arg("category", ku.localize(32008)) # Themes if not href: # Topics menu soup = dws.get_html(dws.DW_MEDIA_ALL_URL) content = soup.find("div", {"id": "themes"}).extract() items = content.find_all("a", "check") for item in items: add_menu_item( topic, item.text, { "href": dws.get_search_url(tid=item.get("value")), "category": item.text }) else: # Topic's playable items soup = dws.get_html(href) parse_search_results(soup, href, topic, category) xbmcplugin.setContent(plugin.handle, "episodes") xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def section(): # type: () -> None """Show category menu and category playable items""" href = get_arg("href") category = get_arg("category", ku.localize(32002)) if not href: # category menu soup = ngs.get_html(ngs.NG_URI) menu = soup.find("ul", "dropdown-menu").extract() for item in menu.find_all("li"): action = item.find("a") add_menu_item(section, action.text, args={ "href": action.get("href"), "category": action.text }) else: # playable items soup = ngs.get_html(ngs.get_url(href)) parse_search_results(soup, category, section) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def play_film(): url = eafa.get_page_url(get_arg("href")) data = eafa.get_html(url) container = data.find("div", {"id": "video-container"}) if not container: return False script = container.find_next_sibling("script") if not script: return False mp4_url = eafa.pluck( eafa.remove_whitespace(script.text), "'hd-2':{'file':'", "'}}});") # TODO: maybe re list_item = ListItem(path=mp4_url) xp.setResolvedUrl(plugin.handle, True, list_item)
def recent(): # type: () -> None """Show recently viewed films""" data = pas.recents.retrieve() for url in data: soup = pas.get_html(url) info = pas.get_info(soup) add_menu_item(play_film, info.get("title"), args={"href": url}, art=ku.art(pas.get_url(info.get("image"))), info=info.get("info"), directory=False) xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32005)) # Recent xbmcplugin.endOfDirectory(plugin.handle)
def play_film(): uri = bcfs.get_page_url(get_arg("href")) data = bcfs.get_html(uri) if data is None: return False link = data.select_one("a[href*={}]".format(bcfs.PLAYER_URI)) if link is None: return False list_item = ListItem(path=link["href"]) dl_data = data.find("dl", "details") plot = data.find("p", "standfirst").text year = dl_data.find( "dt", string="Release year").find_next_sibling("dd").text.strip() list_item.setInfo("video", {"plot": plot, "year": year}) xp.setResolvedUrl(plugin.handle, True, list_item)
def play_film(): # type: () -> None """Show playable item""" href = get_arg("href") url = pas.get_url(href) soup = pas.get_html(url) data = pas.get_info(soup) if not data.get("video"): logger.debug("play_film error: {}".format(href)) return if pas.RECENT_SAVED: pas.recents.append(url) list_item = ListItem(path=data.get("video")) list_item.setInfo("video", data.get("info")) xbmcplugin.setResolvedUrl(plugin.handle, True, list_item)
def search(): query = get_arg("q") href = get_arg("href", False) # remove saved search item if bool(get_arg("delete", False)): jafc.remove(query) xbmc.executebuiltin("Container.Refresh()") return True # View saved search menu if bool(get_arg("menu", False)): add_menu_item(search, "[{}]".format(ku.localize(32016)), {"new": True}) # [New Search] for item in jafc.retrieve(): text = item.encode("utf-8") add_menu_item( search, text, args={"q": text}) xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32007)) # Search xbmcplugin.endOfDirectory(plugin.handle) return True # look-up if bool(get_arg("new", False)): query = ku.user_input() jafc.append(query) if not query: return False url = jafc.get_url(href) if href else jafc.get_search_url(query) data = jafc.get_html(url) results = data.find("ul", "work-results") if not results: return paginate(data.find("ul", "pager-menu"), search) for item in results.find_all("li", "work-result"): action = item.find("a") img = item.find("img", "thumbnail") add_menu_item(play_film, item.find("h2").text, args={"href": action["href"]}, info=jafc.get_info(action["href"]), art=ku.art(jafc.get_url(img["src"])), directory=False) xbmcplugin.setPluginCategory(plugin.handle, "{} '{}'".format(ku.localize(32016), query)) xbmcplugin.endOfDirectory(plugin.handle)
def play_film(): # type: () -> None """Attempts to find the m3u8 file for a give href and play it""" url = bfis.get_page_url(get_arg("href")) video_id = get_arg("video_id") target = get_arg("target") soup = bfis.get_html(url) if not video_id: video_id = soup.find(id=target).get(PLAYER_ID_ATTR) \ if target \ else soup.find(True, attrs={PLAYER_ID_ATTR: True})[PLAYER_ID_ATTR] if video_id: if bfis.RECENT_SAVED: bfis.recents.append((url, video_id)) m3u8 = bfis.get_m3u8_url(video_id) xbmcplugin.setResolvedUrl(plugin.handle, True, ListItem(path=m3u8))
def themes(): """List of directory menu items for each theme""" url = jafc.get_page_url(get_arg("href")) data = jafc.get_html(url) element = data.find("ul", { "class": ["category-condition-keyword", "work-favorites-condition-keyword"] }) for item in element.find_all("li"): action = item.find("a") span = action.find("span") if span: span.extract() title = action.text add_menu_item(films, title, {"href": action["href"], "title": title}) xp.setPluginCategory(plugin.handle, get_arg("title")) xp.endOfDirectory(plugin.handle)
def authors(): """List of authors""" url = jafc.get_url("en/writer.html") data = jafc.get_html(url) container = data.find("ul", "writer-results") for item in container.find_all("li"): action = item.find("a") if action is None: continue add_menu_item(films, action.text, args={"href": "en/{}".format(action["href"]), "title": action.text}, info={"plot": item.find("div", "writer-result-description").text}, art=ku.art(jafc.get_url(item.find("img", "thumbnail")["src"]))) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL) xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32004)) # Authors xbmcplugin.endOfDirectory(plugin.handle)
def collections(): # type: () -> None href = get_arg("href", False) category = get_arg("category", ku.localize(32004)) if not href: # Show the list of collections html = eyes.get_html(eyes.EYE_COLLECTIONS_URI) ul = html.find("ul", {"id": "facetapi-facet-search-apieye-filmgeschiedenis-block-field-coll-sub"}) data = ul.find_all("li", "leaf") for item in data: action = item.find("a", "facetapi-inactive") title = action.contents[0].encode("utf-8").title() add_menu_item(collections, title, args={"href": action["href"], "category": title}) else: parse_results(href, category) xbmcplugin.setPluginCategory(plugin.handle, category) xbmcplugin.endOfDirectory(plugin.handle)
def search(): query = get_arg("q") href = get_arg("href", False) # remove saved search item if bool(get_arg("delete", False)): jafc.remove(query) xbmc.executebuiltin("Container.Refresh()") return True # View saved search menu if bool(get_arg("menu", False)): add_menu_item(search, "[{}]".format(ku.get_string(32016)), {"new": True}) # [New Search] for item in jafc.retrieve(): text = item.encode("utf-8") add_menu_item(search, text, {"q": text}) xp.setPluginCategory(plugin.handle, ku.get_string(32007)) # Search xp.endOfDirectory(plugin.handle) return True # look-up if bool(get_arg("new", False)): query = ku.user_input() jafc.append(query) if not query: return False url = jafc.get_page_url(href) if href else jafc.get_search_url(query) data = jafc.get_html(url) results = data.find("ul", "work-results") if not results: return paginate(data.find("ul", "pager-menu"), search) for item in results.find_all("li", "work-result"): action = item.find("a") img = item.find("img", "thumbnail") add_menu_item(play_film, item.find("h2").text, {"href": action["href"]}, info=get_info(action["href"]), art=ku.art(jafc.get_page_url(img["src"])), directory=False) xp.setPluginCategory(plugin.handle, "{} '{}'".format(ku.get_string(32016), query)) xp.endOfDirectory(plugin.handle)
def themes(): """List of directory menu items for each theme""" url = jafc.get_url(get_arg("href")) data = jafc.get_html(url) element = data.find("ul", { "class": ["category-condition-keyword", "work-favorites-condition-keyword"] }) for item in element.find_all("li"): action = item.find("a") span = action.find("span") if span: span.extract() add_menu_item( films, action.text, args={"href": action["href"], "title": action.text}) xbmcplugin.setPluginCategory(plugin.handle, get_arg("title")) xbmcplugin.endOfDirectory(plugin.handle)
def authors(): """List of authors""" url = jafc.get_page_url("en/writer.html") data = jafc.get_html(url) container = data.find("ul", "writer-results") for item in container.find_all("li"): img = item.find("img", "thumbnail") action = item.find("a") if action is None: continue add_menu_item(films, action.text, args={ "href": "en/{}".format(action["href"]), "title": action.text }, info={ "plot": item.find("div", "writer-result-description").text }, art=ku.art(jafc.get_page_url(img["src"]))) xp.addSortMethod(plugin.handle, xp.SORT_METHOD_LABEL) xp.endOfDirectory(plugin.handle)
def parse_results(href, category): # type: (str, str) -> Union[None, bool] html = eyes.get_html(eyes.get_page_url(href)) paginate(html, category) data = html.find_all("li", "packery-item") for item in data: action = item.find("a") details = eyes.get_info(eyes.get_page_url(action["href"])) add_menu_item(play_film, details["title"], args={"href": action["href"]}, art=details["art"], info=details["info"], directory=False) xbmcplugin.setContent(plugin.handle, "videos") xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_GENRE) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_VIDEO_YEAR) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_DURATION) xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL_IGNORE_THE)
def year(): # type: () -> None """View archive by periods""" period = get_arg("period", False) if not period: # Years menu for item in BP_PERIODS: add_menu_item(year, str(item), args={"period": item}) xbmcplugin.setPluginCategory(plugin.handle, ku.localize(32006)) # Years else: # Period playable items start, end = period.split("-") url = bps.get_search_url(start=start, end=end) soup = bps.get_html(url) paginate(soup, "+", period) parse_search_results(soup) xbmcplugin.setPluginCategory(plugin.handle, period) # YYYY-YYYY xbmcplugin.endOfDirectory(plugin.handle)
def search(): query = get_arg("q") page = int(get_arg("page", 1)) # remove saved search item if bool(get_arg("delete", False)): eafa.remove(query) xbmc.executebuiltin("Container.Refresh()") return True # View saved search menu if bool(get_arg("menu", False)): add_menu_item(search, "[{}]".format(ku.get_string(32016)), {"new": True}) # [New Search] for item in eafa.retrieve(): text = item.encode("utf-8") add_menu_item(search, text, {"q": text}) xp.setPluginCategory(plugin.handle, ku.get_string(32007)) # Search xp.endOfDirectory(plugin.handle) return True # look-up if bool(get_arg("new", False)): query = ku.user_input() eafa.append(query) if not query: return False form = get_form_data(eafa.get_html(eafa.EAFA_SEARCH_URI)) if not form: return False data = eafa.post_html(eafa.EAFA_SEARCH_URI, { "__EVENTTARGET": "ctl00$ContentPlaceHolder1$ucSearch$ToolkitScriptManager1", "__EVENTARGUMENT": eafa.get_search_params(query, page), "__VIEWSTATE": form["state"] }) xp.setPluginCategory( plugin.handle, "{} '{}'".format(ku.get_string(32007), # Search 'query' eafa.query_decode(query)) ) parse_results(data, page, query)
def show_category(): key = get_arg("key", "category") href = get_arg("href", "free") is_dir = bool(get_arg("isdir", False)) category = get_arg("title", ku.get_string(32008)) url = bfis.get_page_url(href) html = bfis.get_html(url) for card in html.findAll(*JIG[key]["card"]): action = card.find(*JIG[key]["action"]) if action is None: continue title = card.find(*JIG[key]["title"]).text.encode("utf-8") info = { "mediatype": "video", "plot": bfis.html_to_text(card.find(*JIG[key]["plot"]).text.encode("utf-8")) } if "meta" in JIG[key]: try: genre, year, duration = card.find_all(*JIG[key]["meta"], limit=3) info["genre"] = genre.text.encode("utf-8") info["year"] = bfis.text_to_int(year.text.encode("utf-8")) info["duration"] = bfis.text_to_int(duration.text.encode("utf-8")) except (ValueError, TypeError): pass add_menu_item( show_category if is_dir else play_film, title, {"href": action["href"], "title": title}, ku.art(card.find("img").attrs), info, is_dir ) xp.setPluginCategory(plugin.handle, category) xp.setContent(plugin.handle, "videos") xp.addSortMethod(plugin.handle, xp.SORT_METHOD_LABEL_IGNORE_THE) xp.addSortMethod(plugin.handle, xp.SORT_METHOD_GENRE) xp.endOfDirectory(plugin.handle)