def __init__(self):
# error message
self.error = None
# establish connection
self.session = build_opener()
# add proxy handler if needed
if config['proxy']:
if any(config['proxies'].values()):
self.session.add_handler(ProxyHandler(config['proxies']))
logger.debug("Proxy is set!")
else:
self.error = "Proxy enabled, but not set!"
# change user-agent
self.session.addheaders = [('User-Agent', config['ua'])]
# load local cookies
mcj = MozillaCookieJar()
try:
mcj.load(FILE_C, ignore_discard=True)
if 'uid' in [cookie.name for cookie in mcj]:
# if cookie.expires < int(time.time())
logger.info("Local cookies is loaded")
self.session.add_handler(HTTPCookieProcessor(mcj))
else:
logger.info("Local cookies expired or bad")
logger.debug(f"That we have: {[cookie for cookie in mcj]}")
mcj.clear()
self.login(mcj)
except FileNotFoundError:
self.login(mcj)
class MozillaCookiejarHandler:
"""Загружает и сохраняет cookies в формате Mozilla"""
def __init__(self, filename='cookies.txt'):
self.mozillaCookieJar = None
self.filename = filename
def cookiejar(self, policy):
def_policy = DefaultCookiePolicy(**policy)
self.mozillaCookieJar = MozillaCookieJar(self.filename, def_policy)
if exists(self.filename):
self.mozillaCookieJar.load(self.filename)
handler = HTTPCookieProcessor(self.mozillaCookieJar)
return handler
def save_cookies(self):
self.mozillaCookieJar.save()
def make_cookies(self, response, request):
cook = self.mozillaCookieJar.make_cookies(response, request)
return cook
def clear_cookies(self, domain=None, path=None, name=None):
self.mozillaCookieJar.clear(domain, path, name)
def __init__(self):
self.header = {
"Accept":
"*/*",
"Accept-Encoding":
"gzip,deflate,sdch",
"Accept-Language":
"zh-CN,zh;q=0.8,gl;q=0.6,zh-TW;q=0.4",
"Connection":
"keep-alive",
"Content-Type":
"application/x-www-form-urlencoded",
"Host":
"music.163.com",
"Referer":
"http://music.163.com",
"User-Agent":
"Mozilla/5.0 (Macintosh; Intel Mac OS X 11_1_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.87 Safari/537.36",
}
self.storage = Storage()
cookie_jar = MozillaCookieJar(self.storage.cookie_path)
cookie_jar.load()
self.session = requests.Session()
self.session.cookies = cookie_jar
for cookie in cookie_jar:
if cookie.is_expired():
cookie_jar.clear()
self.storage.database["user"] = {
"username": "",
"password": "",
"user_id": "",
"nickname": "",
}
self.storage.save()
break
class SessionStore(requests.Session):
"""A ``requests.Session`` subclass implementing a file-based session store."""
def __init__(self, endpoint, persist_cookie, cookie_file, reauthenticate,
login_params, authn_header=None, debug=False):
super(SessionStore, self).__init__()
self.session_base_url = '{0}/api/session'.format(endpoint)
self.reauthenticate = reauthenticate
self.persist_cookie = persist_cookie
self.login_params = login_params
self.authn_header = authn_header
self._debug = debug
if persist_cookie:
if cookie_file is None:
cookie_file = DEFAULT_COOKIE_FILE
cookie_dir = os.path.dirname(cookie_file)
self.cookies = MozillaCookieJar(cookie_file)
# Create the $HOME/.nuvla dir if it doesn't exist
if not os.path.isdir(cookie_dir):
os.mkdir(cookie_dir, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
# Load existing cookies if the cookies.txt exists
if os.path.isfile(cookie_file):
self.cookies.load(ignore_discard=True)
self.cookies.clear_expired_cookies()
def need_to_login(self, accessed_url, status_code):
return self.reauthenticate \
and status_code in [401, 403] \
and accessed_url != self.session_base_url
def _request(self, *args, **kwargs):
kwargs.setdefault('timeout', DEFAULT_TIMEOUT)
if self.authn_header is not None:
headers = kwargs.get('headers', {})
headers['nuvla-authn-info'] = self.authn_header
kwargs['headers'] = headers
return super(SessionStore, self).request(*args, **kwargs)
def request(self, *args, **kwargs):
response = self._request(*args, **kwargs)
if not self.verify and response.cookies:
self._unsecure_cookie(args[1], response)
if self.persist_cookie and 'Set-Cookie' in response.headers:
self.cookies.save(ignore_discard=True)
url = args[1]
if self.need_to_login(url, response.status_code):
login_response = self.cimi_login(self.login_params)
if login_response is not None and login_response.status_code == 201:
# retry the call after reauthentication
response = self._request(*args, **kwargs)
return response
def cimi_login(self, login_params):
self.login_params = login_params
if self.login_params:
method = 'POST'
endpoint = self.session_base_url
headers = {'Content-Type': 'application/json',
'Accept': 'application/json'}
json = {'template': login_params}
if self._debug:
_request_debug(method, endpoint, doc=json, headers=headers)
response = self.request(method, endpoint, headers=headers, json=json)
if self._debug:
_response_debug(response)
return response
else:
return None
def _unsecure_cookie(self, url_str, response):
url = urlparse(url_str)
if url.scheme == 'http':
for cookie in response.cookies:
cookie.secure = False
self.cookies.set_cookie_if_ok(cookie, MockRequest(response.request))
def clear(self, domain):
"""Clear cookies for the specified domain."""
try:
self.cookies.clear(domain)
if self.persist_cookie:
self.cookies.save()
except KeyError:
pass
def __init__(self):
# setup logging into qBittorrent/logs
logging.basicConfig(
handlers=[
logging.FileHandler(self.path_to('../../logs', 'kinozal.log'),
'w', 'utf-8')
],
level=logging.DEBUG,
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
datefmt='%m-%d %H:%M')
try:
# try to load user data from file
with open(self.path_to('kinozal.json'), 'r+') as f:
config = json.load(f)
if "version" not in config.keys():
config.update({"version": 2, "torrentDate": True})
f.seek(0)
f.write(json.dumps(config, indent=4, sort_keys=False))
f.truncate()
self.config = config
except OSError as e:
logging.error(e)
# if file doesn't exist, we'll create it
gui = KinozalGui(self.config)
gui.window.mainloop()
self.config = gui.config
with open(self.path_to('kinozal.json'), 'w') as f:
f.write(json.dumps(self.config, indent=4, sort_keys=False))
# establish connection
self.session = build_opener()
# add proxy handler if needed
if self.config['proxy'] and any(self.config['proxies'].keys()):
self.session.add_handler(ProxyHandler(self.config['proxies']))
# change user-agent
self.session.addheaders.pop()
self.session.addheaders.append(('User-Agent', self.config['ua']))
# avoid endless waiting
self.blocked = False
mcj = MozillaCookieJar()
cookie_file = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'kinozal.cookie'))
# load local cookies
if os.path.isfile(cookie_file):
mcj.load(cookie_file, ignore_discard=True)
if 'uid' in [cookie.name for cookie in mcj]:
# if cookie.expires < int(time.time())
logging.info("Local cookies is loaded")
self.session.add_handler(HTTPCookieProcessor(mcj))
else:
logging.info("Local cookies expired or bad")
logging.debug(f"That we have: {[cookie for cookie in mcj]}")
mcj.clear()
self.login(mcj, cookie_file)
else:
self.login(mcj, cookie_file)
