def _get_sources(self):
#You can get multiple sources from this
soup = helpers.soupify(helpers.get(self.url))
regex = r"data-video-link=\"//[^\"]*"
url = 'https:' + re.search(regex, str(soup)).group().replace(
'data-video-link="', '')
soup = helpers.soupify(helpers.get(url))
url = (soup.select('div > iframe')[0].get('src'))
soup = helpers.soupify(helpers.get(url))
url = re.search(r'https://vidstreaming\.io/download\?[^"]*',
str(soup)).group()
soup = helpers.soupify(helpers.get(url))
url = soup.select('div.dowload > a')[0].get('href')
return [(
'no_extractor',
url,
)]
def search(self, query):
headers = {
'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.46 Safari/537.36'
}
soup = helpers.soupify(helpers.get('https://twist.moe/', allow_redirects=True, headers=headers))
if 'being redirected' in soup.text:
cookie = get_cookie(soup)
with requests_cache.disabled():
headers['cookie'] = cookie
# XXX: Can't use helpers.get here becuse that one is cached. Investigate
r = requests.get('https://twist.moe/', headers=headers)
soup = helpers.soupify(r)
all_anime = soup.select_one('nav.series').select('li')
animes = []
for anime in all_anime:
animes.append(SearchResult(
title=anime.find('span').contents[0].strip(),
url='https://twist.moe' + anime.find('a')['href'],
))
animes = [ani[0] for ani in process.extract(query, animes)]
return animes
def search(cls, query):
soup = helpers.soupify(helpers.get("https://ryuanime.com/browse-anime", params={"search": query}))
result_data = soup.select("li.list-inline-item:has(p.anime-name):has(a.ani-link)")
search_results = [
SearchResult(
title=result.select("p.anime-name")[0].text,
url='https://ryuanime.com' + result.select("a.ani-link")[0].get("href")
)
for result in result_data
]
return search_results
def _get_sources(self):
version = self.config['version']
servers = self.config['servers']
server_links = {
'mp4upload':'https://www.mp4upload.com/embed-{}.html',
'trollvid': 'https://trollvid.net/embed/{}',
'mp4sh': 'https://mp4.sh/embed/{0}{1}',
'vidstreaming':'https://vidstreaming.io/download?id={}'
}
soup = str(helpers.soupify(helpers.get(self.url)))
x = re.search(r"xuath = '([^']*)", soup).group(1)
episode_regex = r'var episode = (.*?});'
api = json.loads(re.search(episode_regex,soup).group(1))
slug = api['slug']
sources = api['videos']
vidstream = helpers.get(f'https://vid.xngine.com/api/episode/{slug}',referer = self.url).json()
for a in vidstream:
if a['host'] == 'vidstreaming' and 'id' in a and 'type' in a:
sources.append(a)
for a in servers: #trying all supported servers in order using the correct language
for b in sources:
if b['type'] == version:
if b['host'] == a:
if get_extractor(a) == None:
continue
else:
provider = a[:]
embed = server_links.get(provider,'{}').format(b['id'],x)
return [(provider, embed,)]
logger.debug('No servers found in selected language. Trying all supported servers')
for a in servers: #trying all supported servers in order
for b in sources:
if b['host'] == a:
if get_extractor(a) == None:
continue
else:
provider = a[:]
embed = server_links.get(provider,'{}').format(b['id'],x)
return [(provider, embed,)]
logger.debug('No supported servers found, trying mp4sh')
if re.search(r'"trollvid","id":"([^"]*)', soup):
token = re.search(r'"trollvid","id":"([^"]*)', soup).group(1)
embed = server_links.get('mp4sh','{}').format(token,x)
return [('mp4sh', embed,)]
else:
logger.debug('No servers found')
return [('no_extractor', '',)]
def search(cls, query):
# Due to how search works some titles cannot get found by the search.
# For example the one piece movies only shows up while in the once piece tab.
soup = helpers.soupify(
helpers.get('https://animetake.tv/search', params={'key': query}))
return [
SearchResult(title=x.find('center').text.strip(),
url='https://animetake.tv{}'.format(x.a['href']),
meta_info={'version_key_dubbed': '(Dubbed)'})
for x in soup.select('div.thumbnail')
]
def _scrape_episodes(self):
soup = helpers.soupify(helpers.get(self.url))
eps = soup.select('a.episode_well_link')
# Sometimes the episodes are listed in reverse (One Piece)
# Will reverse movies, but shouldn't matter.
reverse = "Episode 1" not in eps[0].text
eps = ['https://animetake.tv{}'.format(x['href']) for x in eps]
if reverse:
eps.reverse()
return eps
def search_filler_episodes(query, page):
url = 'https://animefillerlist.com/search/node/'
search_results = helpers.soupify(helpers.get(
url + query, params={'page': page})).select('h3.title > a')
urls = [a.get('href') for a in search_results if a.get(
'href').split('/')[-2] == 'shows']
search_results = [
[
search_results[a].text]
for a in range(len(search_results)) if search_results[a].get('href').split('/')[-2] == 'shows'
]
return search_results, urls
def search(cls, query):
search_results = helpers.soupify(
helpers.get("https://animekisa.tv/search", params={"q": query}))
search_results = search_results.select('div.similarbox > a.an')
search_results = [
SearchResult(title=i.select(
'div > div > div > div > div.similardd')[0].text,
url='https://www.animekisa.tv' + i.get('href'))
for i in search_results if i.get('href') != '/'
]
return search_results
def search(cls, query):
# Only uses the first page of search results, but it's sufficent.
search_results = helpers.soupify(
helpers.get(cls.url, params={'keyword': query})).select('a.name')
return [
SearchResult(title=i.text,
url=i.get('href'),
meta_info={
'version_key_dubbed': '(Dub)',
'version_key_subbed': ''
}) for i in search_results
]
def search(cls, query):
soup = helpers.soupify(
helpers.post('https://vostfree.com',
data={
'do': 'search',
'subaction': 'search',
'story': query
}))
return [
SearchResult(title=re.sub('\s+?FRENCH(\s+)?$', '', x.text.strip()),
url=x['href']) for x in soup.select('div.title > a')
]
def search(cls, query):
search_results = helpers.soupify(
helpers.get(cls._search_url, params={'keyword': query}))
search_results = search_results.select('ul.items > li > p > a')
search_results = [
SearchResult(title=i.get('title'),
url='https://gogoanime.io' + i.get('href'),
meta_info={'version_key_dubbed': '(Dub)'})
for i in search_results
]
return search_results
def _get_sources(self):
server = self.config['server']
soup = helpers.soupify(helpers.get(self.url))
regex = r'var json = ([^;]*)'
sources = json.loads(re.search(
regex, str(soup)).group(1)) #Lots of sources can be found here
for a in sources: #Testing sources with selected language and provider
if a['type'] == self.config['version']:
if a['host'] == self.config['server']:
if get_extractor(a['host']) == None:
server = 'no_extractor'
else:
server = (a['host'])
embed = re.search(r"src=['|\"]([^\'|^\"]*)",
str(a['player']), re.IGNORECASE).group(1)
return [(
server,
embed,
)]
logger.debug(
'Preferred server %s not found. Trying all supported servers in selected language.',
server)
for a in sources: #Testing sources with selected language
if a['type'] == self.config['version']:
if get_extractor(a['host']) == None: server = 'no_extractor'
else: server = (a['host'])
embed = re.search(r"src=['|\"]([^\'|^\"]*)", str(a['player']),
re.IGNORECASE).group(1)
return [(
server,
embed,
)]
logger.debug('No %s servers found, trying all servers',
self.config['version'])
if get_extractor(sources[0]['host']) == None: server = 'no_extractor'
else: server = (sources[0]['host'])
embed = re.search(r"src=['|\"]([^\'|^\"]*)", str(sources[0]['player']),
re.IGNORECASE).group(1)
return [(
server,
embed,
)]
def search(cls, query):
response = helpers.get('https://animebinge.net/search', params={'term': query})
soup = helpers.soupify(response)
results = soup.select('a#epilink')
search_results = [
SearchResult(
title=x.text,
url=x['href']
)
for x in results
]
return search_results
def _scrape_episodes(self):
soup = helpers.soupify(helpers.get(self.url))
ret = [
str(a['href'])
for a in soup.find_all('a', {'class': 'list-group-item'})
]
if ret == []:
err = 'No Episodes Found in url "{}"'.format(self.url)
args = [self.url]
raise NotFoundError(err, *args)
# Could be reversed
return ret
def _get_sources(self):
soup = helpers.soupify(helpers.get(self.url))
iframes = soup.select('iframe')
logger.debug('Iframes: {}'.format(iframes))
for i in iframes:
# Simple check in case there's advertising iframes.
if 'streaming.php' in i.get('src'):
return [(
'vidstream',
i.get('src'),
)]
return ''
def _get_sources(self):
server = self.config.get("server", "trollvid")
soup = helpers.soupify(helpers.get(self.url))
hosts = json.loads(soup.find("div", {"class":"spatry"}).previous_sibling.previous_sibling.text[21:-2])["videos"]
type = hosts[0]["type"]
host = list(filter(lambda video: video["host"] == server and video["type"] == type, hosts))[0]
name = host["host"]
_id = host["id"]
if name == "trollvid":
link = "https://trollvid.net/embed/" + _id
elif name == "mp4upload":
link = f"https://mp4upload.com/embed-{_id}.html"
return [(name, link)]
def search(cls, query):
results = helpers.get("https://www4.ryuanime.com/search",
params={
"term": query
}).text
soup = helpers.soupify(results)
result_data = soup.find("ul", {"class": "list-inline"}).find_all("a")
search_results = [
SearchResult(title=result.text, url=result.get("href"))
for result in result_data
]
return search_results
def search(cls, query):
results = helpers.get(f"http://justdubs.org/search/node/{query}").text
soup = helpers.soupify(results)
results_data = soup.select("li.search-result a[href*='http://justdubs.org/watch-']")
logger.debug(results_data)
search_results = [
SearchResult(
title=result.text,
url=result.get("href")
)
for result in results_data
]
return search_results
def search(cls, query):
base_url = 'https://www.anitube.site'
html = helpers.soupify(helpers.get(base_url, params={'s': query}))
results = html.select('div.aniItem > a')
return [
SearchResult(title=x['title'].split('Temporada')[0].split(
'– Todos')[0].split('Todos os')[0],
url=x['href'],
meta_info={'version_key_dubbed': '(Dublado)'})
for x in html.select('div.aniItem > a')
]
return results
def search(cls, query):
search_url = "http://putlockers.fm/search-movies/{}.html".format(
quote_plus(query))
soup = helpers.soupify(helpers.get(search_url))
search_results = [
SearchResult(title=x.find("img").get("alt"),
url=x.get("href"),
meta_info={'version_key_dubbed': '(dub)'})
for x in soup.select("div.item > a")
]
return search_results
def _scrape_episodes(self):
version = self.config.get("version", "subbed")
soup = helpers.soupify(helpers.get(self.url))
ep_list = [
x for x in soup.select("div.col-sm-6")
if x.find("h5").text == version.title()
][0].find_all("a")
episodes = [x.get("href") for x in ep_list]
if len(episodes) == 0:
logger.warning("No episodes found")
return episodes[::-1]
def search(cls, query):
search_results = helpers.soupify(
helpers.get(cls.url, params={'q': query}))
regex = r'\[{[\W\w]*?}]'
search_results = json.loads(
re.search(regex, str(search_results)).group()) if re.search(
regex, str(search_results)) else ''
search_results = [
SearchResult(title=a['name'],
url=f'https://kickassanime.rs{a["slug"]}')
for a in search_results
]
return (search_results)
def search(cls, query):
soup = helpers.soupify(
helpers.get('https://app.darkanime.stream/api/v1/animes',
params={
'term': query
}).json()['animesHtml'])
soup = soup.find_all('a', href=True)
return [
SearchResult(
title=x.find('h3').text.strip(),
url='https://app.darkanime.stream' + x['href'],
) for x in soup
]
def search(cls, query):
soup = helpers.soupify(
helpers.post("https://genoanime.com/data/searchdata.php",
data={"anime": query}))
search_results = [
SearchResult(title=x.text,
url=x.get("href").replace("./",
"https://genoanime.com/"))
for x in soup.select("h5 > a[href]")
]
return search_results
def _scrape_episodes(self):
version = self.config.get("version", "subbed")
soup = helpers.soupify(helpers.get(self.url))
subbed = []
dubbed = []
_all = soup.find_all("div", {"class":"episode-wrap"})
for i in _all:
ep_type = i.find("div", {"class":re.compile("ep-type type-.* dscd")}).text
if ep_type == 'Sub':
subbed.append(i.find("a").get("data-src"))
elif ep_type == 'Dub':
dubbed.append(i.find("a").get("href"))
return eval(version)
def search(cls, query):
soup = helpers.soupify(
helpers.get('https://www.egyanime.com/a.php',
params={
'term': query
}).text)
search_results = [
SearchResult(title=i.text,
url="https://www.egyanime.com/" + i['href'])
for i in soup.find_all('a', href=True)
]
return search_results
def _scrape_episodes(self):
# This is retarded, you need to replace the url, otherwise it will go to the kissanime site because the links are similar
_referer = self.url.replace("_anime", "kissanime")
_id = helpers.soupify(
helpers.get(_referer)).select("li.addto-later")[0].get("data-id")
#data = self.url.split(",")
#_id = data[1]
#_referer = data[0].replace("_anime", "kissanime")
for i in range(1, 100):
d = helpers.get("https://kissanimefree.xyz/load-list-episode/",
params={
"pstart": i,
"id": _id,
"ide": ""
})
if not d.text: # MOVIES
maxEp = 1
break
maxEp = int(helpers.soupify(d).select("li")[0].text)
if not maxEp == i * 100:
break
return [f"{i},{_id},{_referer}" for i in range(1, maxEp + 1)]
def search(cls, query):
search_results = helpers.soupify(helpers.get(cls.url+'/search.html',params={'keyword': query})).select('a.videoHname')
search_results = [
SearchResult(
title=i.get('title'),
url=cls.url+i.get('href'),
meta_info = {
'version_key_dubbed':'(Dub)',
}
)
for i in search_results
]
return search_results
def search(cls, query):
soup = helpers.soupify(
helpers.get("https://animesuge.io/ajax/anime/search",
params={
"keyword": query
}).json()['html'])
search_results = [
SearchResult(title=x.find("div").text,
url="https://animesuge.io" + x.get('href'))
for x in soup.select("a:not(.more)")
]
return search_results
def search(cls, query):
search_results = helpers.soupify(helpers.get(cls.url, params={'s': query})).select('h3.post-title > a')
# Removes the unneded metadata from the title
# Used by MAL matcher
clean_title_regex = r'\(.*?\)'
return [
SearchResult(
title=i.text,
url=i.get('href'),
meta_info={
'title_cleaned': re.sub(clean_title_regex, "", i.text).strip()
})
for i in search_results
]
