def kwik_resolver(self, link):
scraper = cfscrape.create_scraper()
download_url = link.replace('kwik.cx/e/', 'kwik.cx/f/')
kwik_text = scraper.get(download_url,
headers={
'referer': download_url
}).content
post_url = re.findall(r'action="(.*?)"', kwik_text)
token = re.findall(r'value="(.*?)"', kwik_text)
if len(post_url) > 0 and len(token) > 0:
stream_url = scraper.post(
post_url[0],
headers={
'referer': download_url
},
data={
'_token': token[0]
},
allow_redirects=False).headers['Location']
self.resolved_link = stream_url
elif len(post_url) == 0:
tools.log('Error - No action in kwik scraped url: ' + kwik_text,
'error')
elif len(token) == 0:
tools.log('Error - No token in kwik scaped url:' + kwik_text,
'error')
def request(self, url, page=1, limit=20, data=None):
offset = (page - 1) * limit
add_url = 'page[limit]=%s&page[offset]=%s' % (limit, offset)
if '?' in url:
request_url = self.api_path + url + '&' + add_url
else:
request_url = self.api_path + url + '?' + add_url
if data is None:
response = requests.get(request_url, headers=self.headers)
else:
response = requests.post(request_url,
headers=self.headers,
data=data)
response = self.check_response(response)
if response['status'] != 'OK':
tools.showDialog.notification(
tools.addonName, 'Kitsu Error: Check log for details')
tools.log(
'Kitsu Error: %s - %s' %
(response['code'], response['description']), 'error')
return
return response['content']
def login(self, silent=False):
query = '''
query ($name: String) {
User(name: $name) {
id
}
}
'''
variables = {"name": self.username}
resp = requests.post(self.site,
json={
'query': query,
'variables': variables
})
results = json.loads(resp.content)
if results.has_key('errors'):
if silent != True:
tools.showDialog.notification(tools.addonName,
'AniList - Login unsuccessful')
else:
tools.log('Anilist - Login unsuccessful')
return
tools.setSetting('ani.userid', str(results['data']['User']['id']))
if silent != True:
tools.showDialog.notification(tools.addonName,
'AniList - Logged in successfully')
else:
tools.log('Anilist - Logged in successfully')
return
def login(self, silent=False):
try:
login = requests.post(self.oauth + '/token',
params={
'grant_type': 'password',
'username': self.email,
'password': self.password
},
headers=self.headers)
info = json.loads(login.text)
tools.setSetting('kitsu.access', str(info['access_token']))
tools.setSetting('kitsu.refresh', str(info['refresh_token']))
tools.setSetting('kitsu.create', str(info['created_at']))
tools.setSetting('kitsu.expiry', str(info['expires_in']))
user = requests.get(
'https://kitsu.io/api/edge/users?filter[name]=%s' %
self.username,
headers=self.headers)
userdata = json.loads(user.content)
userdata = userdata['data'][0]
tools.setSetting('kitsu.userid', str(userdata['id']))
if silent != True:
tools.showDialog.notification(
tools.addonName, 'Kitsu - Logged in successfully')
else:
tools.log('Kitsu - Logged in successfully')
except:
if silent != True:
tools.showDialog.notification(tools.addonName,
'Kitsu - Login unsuccessful')
else:
tools.log('Kitsu - Login unsuccessful')
def getPlanned(self):
data_items = []
mal_anime = []
kitsu_ids = []
sort_status = tools.getSetting('planned.sort')
sort = tools.account_sort['mal'][sort_status] % '6'
resp = requests.get(self.site + '/animelist/%s?%s' %
(self.username, sort))
soup = BeautifulSoup(resp.content, 'html.parser')
items = soup.find_all('table', attrs={'class': 'list-table'})
for a in items:
data_items = str(a.get('data-items'))
data_items = data_items.replace('"', '"')
data_items = json.loads(data_items)
for a in data_items:
mal_anime.append(a['anime_id'])
kitsu_ids = Mappings().get_list('mal', mal_anime, 'kitsu')
anime_list = kitsu_api.KitsuBrowser().getListById(kitsu_ids)
anime_list = tools.sort_anime_by_id(anime_list, kitsu_ids)
tools.log(anime_list, 'error') #Should print list of anime
if '-' in sort_status:
anime_list = sorted(anime_list, reverse=True)
return anime_list
def login(self, silent=False):
session = requests.session()
crsf_res = session.get(self.site).text
crsf = (re.compile("<meta name='csrf_token' content='(.+?)'>").findall(crsf_res))[0]
payload = {
"user_name": self.username,
"password": self.password,
"cookie": 1,
"sublogin": "******",
"submit": 1,
"csrf_token": crsf
}
url = self.site + '/login.php?from=%2F'
session.get(url)
result = session.post(url, data=payload)
soup = BeautifulSoup(result.text, 'html.parser')
results = soup.find_all('div', attrs={'class': 'badresult'})
if results:
if silent != True:
tools.showDialog.notification(tools.addonName, 'MAL - Login Unsuccessful')
else:
tools.log('MAL - Login Unsuccessful')
return
tools.setSetting('mal.logsess', str(session.cookies['MALHLOGSESSID']))
tools.setSetting('mal.sessionid', str(session.cookies['MALSESSIONID']))
if silent != True:
tools.showDialog.notification(tools.addonName, 'MAL - Logged in successfully')
else:
tools.log('MAL - Logged in successfully')
return
def track(self, id, episode, status):
self.headers['Authorization'] = 'Bearer %s' % self.access
params = {"filter[user_id]": self.userid, "filter[anime_id]": id}
resp = requests.get('https://kitsu.io/api/edge/library-entries',
headers=self.headers,
params=params)
scrobble = json.loads(resp.content)
if len(scrobble['data']) == 0:
params = {
"data": {
"type": "libraryEntries",
"attributes": {
'status': status,
'progress': int(episode)
},
"relationships": {
"user": {
"data": {
"id": int(self.userid),
"type": "users"
}
},
"anime": {
"data": {
"id": int(id),
"type": "anime"
}
}
}
}
}
resp = requests.post('https://kitsu.io/api/edge/library-entries',
headers=self.headers,
json=params)
tools.log('%s - Successfully Scrobbled')
return
anime_id = scrobble['data'][0]['id']
params = {
'data': {
'id': int(anime_id),
'type': 'libraryEntries',
'attributes': {
'progress': int(episode)
}
}
}
resp = requests.patch('https://kitsu.io/api/edge/library-entries/%s' %
anime_id,
headers=self.headers,
json=params)
return
def link_test(self, test):
try:
if 'cdn.bunny.sh' in test:
return 'Good'
resp = requests.head(test, timeout=20)
if resp.status_code == 200:
return 'Good'
elif resp.status_code == 302:
self.resolved_link = resp.headers['location']
return 'Good'
else:
tools.log('Error - Status Code: ' + resp.status_code, 'error')
return 'Bad'
except:
return 'Bad'
def getListById(self, list, progress=None):
items = []
for a in list:
resp = cache.hummingCache().cacheCheck(Backend().request, 24,
'/anime/%s' % a)
data = json.loads(resp)
data = data['data']
items.append(data)
if progress != None:
items[0]['account_info'] = progress
tools.log(items)
extracted_items = self.extract_items(items)
return extracted_items
def run(self):
while not self.tasks.empty():
if (self.stop_flag and self.stop_flag.isSet()):
return
try:
func, args, kwargs = self.tasks.get(1)
except Empty:
tools.log('Thread exited')
return
try:
func(*args, **kwargs)
except:
import traceback
traceback.print_exc()
finally:
self.tasks.task_done()
def _scrape_hoster_provider(self, provider_name):
try:
i = __import__('providers.hosters.%s' % provider_name,
fromlist=['sub'],
globals=globals())
mod = i.source()
if 'episode' in self.data:
results = mod.tvshow(self.data)
else:
results = mod.movie(self.data)
source = mod.sources(results)
self._store_and_de_dup_sources(source, 'hoster')
except Exception as e:
tools.log('Error with %s:/n%s' % (provider_name, e), 'error')
finally:
self._remove_provider(provider_name)
if action == 'franchise':
from resources.lib.menus import anime
anime.List().franchise(actionArgs, page)
##EPISODES STUFF
if action == 'episode_list':
progress_info = ''
#Convert MAL/AniList to Kitsu item.
if get_kitsu_item == True:
from resources.lib.modules import accounts
from resources.lib.modules import kitsu_api
args = json.loads(tools.unquote(actionArgs))
progress_info = args['account_info']
tools.log(progress_info, 'error')
kitsu_id = accounts.Mappings().get(site, args['id'], 'kitsu')
extracted_info = kitsu_api.KitsuBrowser().getListById(
[kitsu_id], progress=progress_info)[0]
tools.log(extracted_info, 'error')
actionArgs = tools.quote(json.dumps(extracted_info))
else:
args = json.loads(tools.unquote(actionArgs))
progress_info = args['account_info']
from resources.lib.menus import anime
anime.List().episode_list(actionArgs, page, progress_info)
##PLAY
if action == 'play_anime':
#Convert MAL/AniList to Kitsu item.
def getHold(self):
anilist_items = []
kitsu_ids = []
status = 'PAUSED'
sort_status = tools.getSetting('hold.sort')
sort = tools.account_sort['anilist'][sort_status]
query = '''
query ($userId: Int, $userName: String, $status: MediaListStatus, $type: MediaType, $sort: [MediaListSort]) {
MediaListCollection(userId: $userId, userName: $userName, status: $status, type: $type, sort: $sort) {
lists {
entries {
...mediaListEntry
}
}
}
}
fragment mediaListEntry on MediaList {
id
mediaId
status
progress
customLists
media {
id
title {
userPreferred
}
coverImage {
extraLarge
}
status
episodes
}
}
'''
variables = {
'userId': int(self.user_id),
'username': self.username,
'status': status,
'type': 'ANIME',
'sort': [sort]
}
resp = requests.post(self.site,
json={
'query': query,
'variables': variables
})
results = json.loads(resp.content)
if results.has_key('errors'):
return
try:
entries = results['data']['MediaListCollection']['lists'][0][
'entries']
except:
entries = []
for a in entries:
anilist_items.append(a['media']['id'])
kitsu_ids = Mappings.get_list('anilist', anilist_items, 'kitsu')
anime_list = kitsu_api.KitsuBrowser().getListById(kitsu_ids)
tools.log(anime_list, 'error') #Should print list of anime
anime_list = tools.sort_anime_by_id(anime_list, kitsu_ids)
tools.log(anime_list, 'error') #Should print list of anime
if '-' in sort_status:
anime_list = sorted(anime_list, reverse=True)
return anime_list
# -*- coding: utf-8 -*-
import xbmc
from resources.lib.modules import tools
from resources.lib.modules import accounts
tools.log('HUMMINGBIRD - STARTING SERVICE')
monitor = xbmc.Monitor()
tools.log(
'Making sure your still logged in cause the addon breaks if your not...')
login_status = tools.checkLoginStatus()
if login_status == True:
accounts.Kitsu().login(silent=True)
accounts.Mal().login(silent=True)
accounts.Anilist().login(silent=True)
tools.log('Successfully logged in again to make the addon work...')
while not monitor.abortRequested():
try:
if monitor.waitForAbort(60 * 15):
break
except:
continue
