Files
universal-web-api/venv/Lib/site-packages/DrissionPage/_configs/session_options.py
T
2026-11-02 22:54:14 +08:00

372 lines
10 KiB
Python

# -*- coding:utf-8 -*-
"""
@Author : g1879
@Contact : g1879@qq.com
@Website : https://DrissionPage.cn
@Copyright: (c) 2020 by g1879, Inc. All Rights Reserved.
"""
from copy import copy
from pathlib import Path
from requests import Session
from requests.structures import CaseInsensitiveDict
from .options_manage import OptionsManager
from .._functions.cookies import cookies_to_tuple, set_session_cookies
from .._functions.settings import Settings as _S
from .._functions.web import format_headers
class SessionOptions(object):
def __init__(self, read_file=True, ini_path=None):
self.ini_path = None
self._download_path = '.'
self._timeout = 10
self._del_set = set() # 记录要从ini文件删除的参数
if read_file is False:
ini_path = False
self.ini_path = None
elif ini_path:
ini_path = Path(ini_path).absolute()
if not ini_path.exists():
raise FileNotFoundError(_S._lang.join(_S._lang.INI_NOT_FOUND, PATH=ini_path))
self.ini_path = str(ini_path)
else:
self.ini_path = str(Path(__file__).parent / 'configs.ini')
om = OptionsManager(ini_path)
self._headers = None
self._cookies = None
self._auth = None
self._proxies = None
self._hooks = None
self._params = None
self._verify = None
self._cert = None
self._adapters = None
self._stream = None
self._trust_env = None
self._max_redirects = None
options = om.session_options
if options.get('headers', None) is not None:
self.set_headers(options['headers'])
if options.get('cookies', None) is not None:
self.set_cookies(options['cookies'])
if options.get('auth', None) is not None:
self._auth = options['auth']
if options.get('params', None) is not None:
self._params = options['params']
if options.get('verify', None) is not None:
self._verify = options['verify']
if options.get('cert', None) is not None:
self._cert = options['cert']
if options.get('stream', None) is not None:
self._stream = options['stream']
if options.get('trust_env', None) is not None:
self._trust_env = options['trust_env']
if options.get('max_redirects', None) is not None:
self._max_redirects = options['max_redirects']
self.set_proxies(om.proxies.get('http', None), om.proxies.get('https', None))
self._timeout = om.timeouts.get('base', 10)
self._download_path = om.paths.get('download_path', '.') or '.'
others = om.others
self._retry_times = others.get('retry_times', 3)
self._retry_interval = others.get('retry_interval', 2)
def __repr__(self):
return f'<SessionOptions at {id(self)}>'
# ===========须独立处理的项开始============
@property
def download_path(self):
return self._download_path
def set_download_path(self, path):
self._download_path = '.' if path is None else str(path)
return self
@property
def timeout(self):
return self._timeout
def set_timeout(self, second):
self._timeout = second
return self
@property
def proxies(self):
if self._proxies is None:
self._proxies = {}
return self._proxies
def set_proxies(self, http=None, https=None):
self._sets('proxies', {'http': http, 'https': https})
return self
@property
def retry_times(self):
return self._retry_times
@property
def retry_interval(self):
return self._retry_interval
def set_retry(self, times=None, interval=None):
if times is not None:
self._retry_times = times
if interval is not None:
self._retry_interval = interval
return self
# ===========须独立处理的项结束============
@property
def headers(self):
if self._headers is None:
self._headers = {}
return self._headers
def set_headers(self, headers):
if headers is None:
self._headers = None
self._del_set.add('headers')
else:
headers = format_headers(headers)
self._headers = {key.lower(): headers[key] for key in headers}
return self
def set_a_header(self, name, value):
if self._headers is None:
self._headers = {}
self._headers[name.lower()] = value
return self
def remove_a_header(self, name):
if self._headers is None:
return self
self._headers.pop(name.lower(), None)
return self
def clear_headers(self):
self._headers = None
self._del_set.add('headers')
@property
def cookies(self):
if self._cookies is None:
self._cookies = []
return self._cookies
def set_cookies(self, cookies):
cookies = cookies if cookies is None else list(cookies_to_tuple(cookies))
self._sets('cookies', cookies)
return self
@property
def auth(self):
return self._auth
def set_auth(self, auth):
self._sets('auth', auth)
return self
@property
def hooks(self):
if self._hooks is None:
self._hooks = {}
return self._hooks
def set_hooks(self, hooks):
self._hooks = hooks
return self
@property
def params(self):
if self._params is None:
self._params = {}
return self._params
def set_params(self, params):
self._sets('params', params)
return self
@property
def verify(self):
return self._verify
def set_verify(self, on_off):
self._sets('verify', on_off)
return self
@property
def cert(self):
return self._cert
def set_cert(self, cert):
self._sets('cert', cert)
return self
@property
def adapters(self):
if self._adapters is None:
self._adapters = []
return self._adapters
def add_adapter(self, url, adapter):
self._adapters.append((url, adapter))
return self
@property
def stream(self):
return self._stream
def set_stream(self, on_off):
self._sets('stream', on_off)
return self
@property
def trust_env(self):
return self._trust_env
def set_trust_env(self, on_off):
self._sets('trust_env', on_off)
return self
@property
def max_redirects(self):
return self._max_redirects
def set_max_redirects(self, times):
self._sets('max_redirects', times)
return self
def _sets(self, arg, val):
if val is None:
self.__setattr__(f'_{arg}', None)
self._del_set.add(arg)
else:
self.__setattr__(f'_{arg}', val)
if arg in self._del_set:
self._del_set.remove(arg)
def save(self, path=None):
if path == 'default':
path = (Path(__file__).parent / 'configs.ini').absolute()
elif path is None:
if self.ini_path:
path = Path(self.ini_path).absolute()
else:
path = (Path(__file__).parent / 'configs.ini').absolute()
else:
path = Path(path).absolute()
path = path / 'config.ini' if path.is_dir() else path
if path.exists():
om = OptionsManager(path)
else:
om = OptionsManager(self.ini_path or (Path(__file__).parent / 'configs.ini'))
options = session_options_to_dict(self)
for i in options:
if i not in ('download_path', 'timeout', 'proxies'):
om.set_item('session_options', i, options[i])
om.set_item('paths', 'download_path', self.download_path or '')
om.set_item('timeouts', 'base', self.timeout)
om.set_item('proxies', 'http', self.proxies.get('http', ''))
om.set_item('proxies', 'https', self.proxies.get('https', ''))
om.set_item('others', 'retry_times', self.retry_times)
om.set_item('others', 'retry_interval', self.retry_interval)
for i in self._del_set:
if i == 'download_path':
om.set_item('paths', 'download_path', '')
elif i == 'proxies':
om.set_item('proxies', 'http', '')
om.set_item('proxies', 'https', '')
else:
om.remove_item('session_options', i)
path = str(path)
om.save(path)
return path
def save_to_default(self):
return self.save('default')
def as_dict(self):
return session_options_to_dict(self)
def make_session(self):
s = Session()
h = CaseInsensitiveDict(self.headers) if self.headers else CaseInsensitiveDict()
if self.cookies:
set_session_cookies(s, self.cookies)
if self.adapters:
for url, adapter in self.adapters:
s.mount(url, adapter)
for i in ['auth', 'proxies', 'hooks', 'params', 'verify', 'cert', 'stream', 'trust_env', 'max_redirects']:
attr = self.__getattribute__(i)
if attr:
s.__setattr__(i, attr)
return s, h
def from_session(self, session, headers=None):
self._headers = CaseInsensitiveDict(copy(session.headers).update(headers)) if headers else session.headers
self._cookies = session.cookies
self._auth = session.auth
self._proxies = session.proxies
self._hooks = session.hooks
self._params = session.params
self._verify = session.verify
self._cert = session.cert
self._stream = session.stream
self._trust_env = session.trust_env
self._max_redirects = session.max_redirects
if session.adapters:
self._adapters = [(k, i) for k, i in session.adapters.items()]
return self
def session_options_to_dict(options):
if options in (False, None):
return SessionOptions(read_file=False).as_dict()
if isinstance(options, dict):
return options
re_dict = dict()
attrs = ['headers', 'cookies', 'proxies', 'params', 'verify', 'stream', 'trust_env', 'cert',
'max_redirects', 'timeout', 'download_path']
for attr in attrs:
val = options.__getattribute__(f'_{attr}')
if val is not None:
re_dict[attr] = val
return re_dict