def set_page_proxy(self, proxy_string, auth_string):
if not proxy_string:
return
pr = proxy_string.split(':', 1)
if len(pr) != 2:
logger.error(self.control.prepend_id('Invalid proxy string {}, auth {}'.format(proxy_string, auth_string)))
return
host = pr[0]
port = int(pr[1])
if not (host and port):
logger.error(self.control.prepend_id('Invalid proxy string {}, auth {}'.format(proxy_string, auth_string)))
return
if auth_string:
aus = auth_string.split(':', 1)
if len(aus) != 2:
logger.error(self.control.prepend_id('Invalid proxy string {}, auth {}'.format(proxy_string, auth_string)))
return
user = aus[0]
password = aus[1]
self.proxy = QNetworkProxy(QNetworkProxy.HttpProxy, host, port, user, password)
else:
self.proxy = QNetworkProxy(QNetworkProxy.HttpProxy, host, port)
def __init__(self, parent):
"""
Copies the properties from the parent (WebEngineRenderer) object,
creates the required instances of QWebPage, QWebView and QMainWindow
and registers some Slots.
"""
QObject.__init__(self)
# Copy properties from parent
for key, value in parent.__dict__.items():
setattr(self, key, value)
# Determine Proxy settings
proxy = QNetworkProxy(QNetworkProxy.NoProxy)
if 'http_proxy' in os.environ:
proxy_url = QUrl(os.environ['http_proxy'])
if proxy_url.scheme().startswith('http'):
protocol = QNetworkProxy.HttpProxy
else:
protocol = QNetworkProxy.Socks5Proxy
proxy = QNetworkProxy(protocol, proxy_url.host(), proxy_url.port(),
proxy_url.userName(), proxy_url.password())
# Create and connect required PyQt5 objects
self._page = CustomWebPage(logger=self.logger,
ignore_alert=self.ignoreAlert,
ignore_confirm=self.ignoreConfirm,
ignore_prompt=self.ignorePrompt,
interrupt_js=self.interruptJavaScript)
self._qt_proxy = QNetworkProxy()
self._qt_proxy.setApplicationProxy(proxy)
self._view = QWebEngineView()
self._view.setPage(self._page)
_window_flags = Qt.WindowFlags()
self._window = QMainWindow(flags=_window_flags)
self._window.setCentralWidget(self._view)
self._qt_network_access_manager = QNetworkAccessManager()
# Import QWebSettings
for key, value in self.qWebSettings.items():
self._page.settings().setAttribute(key, value)
# Connect required event listeners
# assert False, "Not finish"
self._page.loadFinished.connect(self._on_load_finished)
self._page.loadStarted.connect(self._on_load_started)
self._qt_network_access_manager.sslErrors.connect(self._on_ssl_errors)
self._qt_network_access_manager.finished.connect(self._on_each_reply)
# The way we will use this, it seems to be unnecessary to have Scrollbars enabled
self._scroll_area = QAbstractScrollArea()
self._scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self._scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# Show this widget
self._window.show()
def startNetwork(args):
if all(
(args.proxyHost, args.proxyPort, args.proxyUser, args.proxyPassword)):
proxy = QNetworkProxy(QNetworkProxy.HttpProxy, args.proxyHost,
args.proxyPort, args.proxyUser,
args.proxyPassword)
else:
proxy = QNetworkProxy(QNetworkProxy.NoProxy)
manager = QgsNetworkAccessManager().instance()
manager.setFallbackProxyAndExcludes(proxy, [], [])
def create_proxy(host, port, username=None, password=None, type=None):
""" Create a new QNetworkProxy object """
if type is None:
type = 'HTTP'
validate_proxy_type(type)
proxy_type = PROXY_TYPES[type.upper()]
port = int(port)
if username is not None and password is not None:
proxy = QNetworkProxy(proxy_type, host, port, username, password)
else:
proxy = QNetworkProxy(proxy_type, host, port)
return proxy
def __init__(self,
proxyprotocol=QNetworkProxy.Socks5Proxy,
proxyhostname="127.0.0.1",
proxyhostport=1080,
targethosturl="http://www.google.com",
getproxyStatus=False,
timeout=False):
self.protocol = proxyprotocol
self.proxyhostName = proxyhostname
self.port = int(proxyhostport)
self.url = targethosturl
self.proxyStatus = getproxyStatus
self.reply = None
self.stopCheckProxy = None
self.req = None
self.qnam = QNetworkAccessManager()
if (self.proxyStatus):
self.req = QNetworkRequest(QUrl(self.url))
self.proxy = QNetworkProxy()
self.proxy.setType(self.protocol)
self.proxy.setHostName(self.proxyhostName)
self.proxy.setPort(self.port)
self.proxy.setApplicationProxy(self.proxy)
if timeout == 0:
self.startRequest()
else:
self.stopCheckProxy = QTimer()
self.stopCheckProxy.timeout.connect(self.timeoutStopCheckProxy)
self.stopCheckProxy.setSingleShot(True)
if timeout > 15 or timeout < 0:
timeout = 5
# after five seconds stop checking the proxy and destroy this class
self.stopCheckProxy.start(1000 * timeout)
self.startRequest()
def set_proxy_in_qt_app(hostname, port):
logging.info(f"Set proxy to {hostname}:{port} in Qt application")
network_proxy = QNetworkProxy()
network_proxy.setType(QNetworkProxy.HttpProxy)
network_proxy.setHostName(hostname)
network_proxy.setPort(port)
QNetworkProxy.setApplicationProxy(network_proxy)
def __init__(self, args):
global emacs_width, emacs_height, eaf_config_dir
dbus.service.Object.__init__(
self,
dbus.service.BusName(EAF_DBUS_NAME, bus=dbus.SessionBus()),
EAF_OBJECT_NAME)
(emacs_width, emacs_height, proxy_host, proxy_port, proxy_type, config_dir, var_dict_string) = args
emacs_width = int(emacs_width)
emacs_height = int(emacs_height)
eaf_config_dir = os.path.expanduser(config_dir)
self.buffer_dict = {}
self.view_dict = {}
self.emacs_var_dict = {}
self.update_emacs_var_dict(var_dict_string)
self.start_finish()
self.session_file = os.path.join(eaf_config_dir, "session.json")
# Set Network proxy.
if proxy_host != "" and proxy_port != "":
proxy = QNetworkProxy()
if proxy_type == "socks5":
proxy.setType(QNetworkProxy.Socks5Proxy)
elif proxy_type == "http":
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName(proxy_host)
proxy.setPort(int(proxy_port))
QNetworkProxy.setApplicationProxy(proxy)
def proxy_from_url(url: QUrl) -> Union[QNetworkProxy, pac.PACFetcher]:
"""Create a QNetworkProxy from QUrl and a proxy type.
Args:
url: URL of a proxy (possibly with credentials).
Return:
New QNetworkProxy.
"""
ensure_valid(url)
scheme = url.scheme()
if scheme in ['pac+http', 'pac+https', 'pac+file']:
fetcher = pac.PACFetcher(url)
fetcher.fetch()
return fetcher
types = {
'http': QNetworkProxy.HttpProxy,
'socks': QNetworkProxy.Socks5Proxy,
'socks5': QNetworkProxy.Socks5Proxy,
'direct': QNetworkProxy.NoProxy,
}
if scheme not in types:
raise InvalidProxyTypeError(scheme)
proxy = QNetworkProxy(types[scheme], url.host())
if url.port() != -1:
proxy.setPort(url.port())
if url.userName():
proxy.setUser(url.userName())
if url.password():
proxy.setPassword(url.password())
return proxy
def __init__(self, args):
global emacs_width, emacs_height
dbus.service.Object.__init__(
self, dbus.service.BusName(EAF_DBUS_NAME, bus=dbus.SessionBus()),
EAF_OBJECT_NAME)
(emacs_width, emacs_height, proxy_host, proxy_port) = args
emacs_width = int(emacs_width)
emacs_height = int(emacs_height)
self.buffer_dict = {}
self.view_dict = {}
self.start_finish()
self.session_file_path = os.path.expanduser(
"~/.emacs.d/eaf/session.json")
# Set HTTP proxy.
if proxy_host != "" and proxy_port != "":
proxy = QNetworkProxy()
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName(proxy_host)
proxy.setPort(int(proxy_port))
QNetworkProxy.setApplicationProxy(proxy)
def main():
import sys
QCoreApplication.setOrganizationName("QtExamples")
QCoreApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
# QtWebEngine::initialize()
if QT_NO_WIDGETS:
app = QApplication(sys.argv)
else:
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
server = Server(engine)
engine.load(QUrl("qrc:/main.qml"))
QTimer.singleShot(0, server.run)
proxy = QNetworkProxy()
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName("localhost")
proxy.setPort(5555)
QNetworkProxy.setApplicationProxy(proxy)
sys.exit(app.exec_())
def proxy_from_url(url):
"""
Create a QNetworkProxy from an url.
"""
if not isinstance(url, QUrl):
url = QUrl.fromUserInput(url)
if not url.isValid():
raise RuntimeError("Invalid url %s" % url.toString())
scheme = url.scheme()
types = {
'http': QNetworkProxy.HttpProxy,
'socks': QNetworkProxy.Socks5Proxy,
'socks5': QNetworkProxy.Socks5Proxy,
'direct': QNetworkProxy.NoProxy,
}
if scheme not in types:
raise RuntimeError("scheme %s for url is invalid" % scheme)
proxy = QNetworkProxy(types[scheme], url.host())
if url.port() != -1:
proxy.setPort(url.port())
if url.userName():
proxy.setUser(url.userName())
if url.password():
proxy.setPassword(url.password())
return proxy
def queryProxy(self, query):
return [
QNetworkProxy(QNetworkProxy.HttpProxy,
hostName=self.config['host'],
port=self.config['port'],
user=self.config['user'],
password=self.config['password'])
]
def newsite(self):
while not self.request():
QtWidgets.qApp.processEvents()
print('Proxy bad')
QtWidgets.qApp.processEvents()
QNetworkProxy.setApplicationProxy(QNetworkProxy(QNetworkProxy.HttpProxy, self.proxi_ip, self.proxi_port))
self.load(QUrl('https://vk.com/id447929742?z=video447929742_456239017%2F2819f4855e1e422801%2Fpl_wall_447929742'))
return True
def transform(self, value):
if not value:
return None
elif value == 'system':
return SYSTEM_PROXY
elif value == 'none':
return QNetworkProxy(QNetworkProxy.NoProxy)
url = QUrl(value)
typ = self.PROXY_TYPES[url.scheme()]
proxy = QNetworkProxy(typ, url.host())
if url.port() != -1:
proxy.setPort(url.port())
if url.userName():
proxy.setUser(url.userName())
if url.password():
proxy.setPassword(url.password())
return proxy
def set_proxy_settings():
http = backend.pm.Iface().getConfig().get("general", "http_proxy")
if http and not http == "None":
items = parse_proxy(http)
QNetworkProxy.setApplicationProxy(
QNetworkProxy(QNetworkProxy.HttpProxy, items['host'],
int(items['port']), items['user'] or '',
items['pass'] or ''))
def __init__(self, args):
global emacs_width, emacs_height, eaf_config_dir, proxy_string
(emacs_width, emacs_height, proxy_host, proxy_port, proxy_type,
config_dir, emacs_server_port, var_dict_string) = args
emacs_width = int(emacs_width)
emacs_height = int(emacs_height)
eaf_config_dir = os.path.join(os.path.expanduser(config_dir), '')
self.buffer_dict = {}
self.view_dict = {}
self.emacs_var_dict = {}
self.update_emacs_var_dict(var_dict_string)
self.server = ThreadingEPCServer(('localhost', 0), log_traceback=True)
self.server.logger.setLevel(logging.DEBUG)
ch = logging.FileHandler(
filename=os.path.expanduser('~/.emacs.d/eaf/epc_log.txt'),
mode='w')
ch.setLevel(logging.DEBUG)
self.server.logger.addHandler(ch)
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.allow_reuse_address = True
self.server.register_instance(self)
self.server_thread.start()
# NOTE:
# Emacs epc client need fetch port from Python process print.
# And this print must be first print code, otherwise Emacs client will failed to start.
self.server.print_port()
self.emacs_server_connect = build_emacs_server_connect(
int(emacs_server_port))
self.first_start(self.webengine_include_private_codec())
self.session_file = os.path.join(eaf_config_dir, "session.json")
# Set Network proxy.
if proxy_host != "" and proxy_port != "":
proxy_string = "{0}://{1}:{2}".format(proxy_type, proxy_host,
proxy_port)
proxy = QNetworkProxy()
if proxy_type == "socks5":
proxy.setType(QNetworkProxy.Socks5Proxy)
elif proxy_type == "http":
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName(proxy_host)
proxy.setPort(int(proxy_port))
QNetworkProxy.setApplicationProxy(proxy)
def __init__(self, config, parent=None, **kwargs):
"""Constructor for the class"""
super(WcgWebView, self).__init__(parent)
self.kwargs = kwargs
self.config = config
self.nam = (kwargs.get('networkAccessManager')
or WcgNetworkAccessManager())
self.setPage(WCGWebPage(config=config))
self.page().setNetworkAccessManager(self.nam)
self.settings().setAttribute(QWebSettings.JavascriptCanOpenWindows,
config.get("allow_popups"))
if config.get('user_css'):
self.settings().setUserStyleSheetUrl(QUrl(config.get('user_css')))
# JavascriptCanCloseWindows is in the API documentation,
# but apparently only exists after 4.8
if QT_VERSION_STR >= '4.8':
self.settings().setAttribute(
QWebSettings.JavascriptCanCloseWindows,
config.get("allow_popups"))
self.settings().setAttribute(QWebSettings.PrivateBrowsingEnabled,
config.get("privacy_mode"))
self.settings().setAttribute(QWebSettings.LocalStorageEnabled, True)
self.settings().setAttribute(QWebSettings.PluginsEnabled,
config.get("allow_plugins"))
self.page().setForwardUnsupportedContent(
config.get("allow_external_content"))
self.setZoomFactor(config.get("zoom_factor"))
# add printing to context menu if it's allowed
if config.get("allow_printing"):
self.print_action = QAction("Print", self)
self.print_action.setIcon(QIcon.fromTheme("document-print"))
self.print_action.triggered.connect(self.print_webpage)
self.page().printRequested.connect(self.print_webpage)
self.print_action.setToolTip("Print this web page")
# Set up the proxy if there is one set
if config.get("proxy_server"):
if ":" in config["proxy_server"]:
proxyhost, proxyport = config["proxy_server"].split(":")
else:
proxyhost = config["proxy_server"]
proxyport = 8080
self.nam.setProxy(
QNetworkProxy(QNetworkProxy.HttpProxy, proxyhost,
int(proxyport)))
# connections for wcgwebview
self.page().networkAccessManager().authenticationRequired.connect(
self.auth_dialog)
self.page().unsupportedContent.connect(self.handle_unsupported_content,
type=Qt.QueuedConnection)
self.page().downloadRequested.connect(self.download)
self.page().networkAccessManager().sslErrors.connect(
self.sslErrorHandler)
self.urlChanged.connect(self.onLinkClick)
self.loadFinished.connect(self.onLoadFinished)
def _setupProxy( self ):
# TODO: move proxy settings to ToolBOS.conf
proxy = QNetworkProxy( )
proxy.setType( QNetworkProxy.HttpProxy )
proxy.setHostName( 'hri-proxy.honda-ri.de' )
proxy.setPort( 3128 )
QNetworkProxy.setApplicationProxy( proxy )
def disable_proxy(self):
global proxy_string
proxy_string = ""
proxy = QNetworkProxy()
proxy.setType(QNetworkProxy.NoProxy)
self.is_proxy = False
QNetworkProxy.setApplicationProxy(proxy)
def setautoupdateProxy(self, proxy):
self.proxy = QNetworkProxy()
protocol = copy.deepcopy(proxy[0])
proxyhostName = copy.deepcopy(proxy[1])
proxyPort = copy.deepcopy(proxy[2])
self.proxy.setType(protocol)
self.proxy.setHostName(proxyhostName)
self.proxy.setPort(int(proxyPort))
self.proxy.setApplicationProxy(self.proxy)
def configure_proxy(self):
proxy = urlparse(
os.environ.get('http_proxy') or os.environ.get('HTTP_PROXY'))
if proxy.hostname is not None and proxy.port is not None:
q_network_proxy = QNetworkProxy(QNetworkProxy.HttpProxy,
proxy.hostname, proxy.port)
if proxy.username is not None:
q_network_proxy.setUser(proxy.username)
if proxy.password is not None:
q_network_proxy.setPassword(proxy.password)
QNetworkProxy.setApplicationProxy(q_network_proxy)
def __init__(self, parent=None, user_id=None):
super().__init__()
self.parent = parent
self.chekLoadFinish = False
# Connect sql and get data
os.chdir('/root/PycharmProjects/HearSheep')
con = sql.connect(os.getcwd() + '/db/db.sqlite3')
cur = con.cursor()
with con:
cur.execute(
'SELECT login, pass, proxy, user_agent FROM accaunt where user_id=?',
(user_id, ))
row = cur.fetchone()
self.login, self.password, proxy, user_agent = row
con.close()
#Path Cookies
os.chdir('/root/PycharmProjects/HearSheep')
pathCookies = '/root/PycharmProjects/HearSheep/cookies/' + str(user_id)
if os.path.exists(pathCookies):
pass
else:
os.chdir('/root/PycharmProjects/HearSheep/cookies')
os.mkdir(str(user_id))
pathCookies = '/root/PycharmProjects/HearSheep/cookies/' + str(
user_id)
# settings
profile = self.page().profile()
profile.setPersistentStoragePath(pathCookies)
profile.setHttpUserAgent(user_agent)
profile.setHttpAcceptLanguage("ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4")
urlinfo = parse.urlparse(proxy)
self.proxy = QNetworkProxy()
self.proxy.setType(QNetworkProxy.HttpProxy)
self.proxy.setHostName(urlinfo.hostname)
self.proxy.setPort(urlinfo.port)
self.proxy.setUser(urlinfo.username)
self.proxy.setPassword(urlinfo.password)
QNetworkProxy.setApplicationProxy(self.proxy)
#
self.page().proxyAuthenticationRequired.connect(
self.handleProxyAuthReq)
self.loadStarted.connect(self.loadStart)
self.loadFinished.connect(self.loadFinish)
self.load(QtCore.QUrl('https://vk.com'))
class ProxyManager(QNetworkProxyFactory):
no_proxy = (QNetworkProxy(),)
def __init__(self, access_manager):
super().__init__()
self.control = access_manager.control
self.access_manager = access_manager
def queryProxy(self, query=None, *args, **kwargs):
if self.access_manager.proxy is not None:
return (self.access_manager.proxy,)
return ProxyManager.no_proxy
def _parse_proxy_entry(proxy_str):
"""Parse one proxy string entry, as described in PAC specification."""
config = [c.strip() for c in proxy_str.split(' ') if c]
if not config:
raise ParseProxyError("Empty proxy entry")
elif config[0] == "DIRECT":
if len(config) != 1:
raise ParseProxyError("Invalid number of parameters for " +
"DIRECT")
return QNetworkProxy(QNetworkProxy.NoProxy)
elif config[0] == "PROXY":
if len(config) != 2:
raise ParseProxyError("Invalid number of parameters for PROXY")
host, port = PACResolver._parse_proxy_host(config[1])
return QNetworkProxy(QNetworkProxy.HttpProxy, host, port)
elif config[0] in ["SOCKS", "SOCKS5"]:
if len(config) != 2:
raise ParseProxyError("Invalid number of parameters for SOCKS")
host, port = PACResolver._parse_proxy_host(config[1])
return QNetworkProxy(QNetworkProxy.Socks5Proxy, host, port)
else:
err = "Unknown proxy type: {}"
raise ParseProxyError(err.format(config[0]))
def set_proxy(string_proxy):
proxy = QNetworkProxy()
urlinfo = urlparse.urlparse(string_proxy)
if urlinfo.scheme == 'socks5':
proxy.setType(QNetworkProxy.Socks5Proxy)
elif urlinfo.scheme == 'http':
proxy.setType(QNetworkProxy.HttpProxy)
else:
proxy.setType(QNetworkProxy.NoProxy)
proxy.setHostName(urlinfo.hostname)
proxy.setPort(urlinfo.port)
proxy.setUser(urlinfo.username)
proxy.setPassword(urlinfo.password)
QNetworkProxy.setApplicationProxy(proxy)
def enable_proxy(self):
global proxy_string
proxy_string = "{0}://{1}:{2}".format(self.proxy[0], self.proxy[1], self.proxy[2])
proxy = QNetworkProxy()
if self.proxy[0] == "socks5":
proxy.setType(QNetworkProxy.Socks5Proxy)
elif self.proxy[0] == "http":
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName(self.proxy[1])
proxy.setPort(int(self.proxy[2]))
self.is_proxy = True
QNetworkProxy.setApplicationProxy(proxy)
def configure_proxy(self):
try:
from urllib.parse import unquote
except ImportError:
from urllib import unquote
url = os.environ.get('http_proxy') or os.environ.get('HTTP_PROXY') or ''
url_decode = unquote(url)
proxy = urlparse(url_decode)
if proxy.hostname is not None and proxy.port is not None:
q_network_proxy = QNetworkProxy(QNetworkProxy.HttpProxy, proxy.hostname, proxy.port)
if proxy.username is not None:
q_network_proxy.setUser(proxy.username)
if proxy.password is not None:
q_network_proxy.setPassword(proxy.password)
QNetworkProxy.setApplicationProxy(q_network_proxy)
def run(self):
# To work around funky GC conflicts with C++ code by ensuring QApplication terminates last
global app
signal.signal(signal.SIGTERM, on_sigterm)
signal.signal(signal.SIGINT, signal.SIG_DFL)
cfg = config.load()
argv = sys.argv.copy()
if self.display_mode == config.DisplayMode.HIDDEN:
argv += ["-platform", "minimal"]
app = QApplication(argv)
if self.proxy:
parsed = urlparse(self.proxy)
if parsed.scheme.startswith("socks5"):
proxy_type = QNetworkProxy.Socks5Proxy
elif parsed.scheme.startswith("http"):
proxy_type = QNetworkProxy.HttpProxy
else:
raise ValueError("Unsupported proxy type", parsed.scheme)
proxy = QNetworkProxy(proxy_type, parsed.hostname, parsed.port)
QNetworkProxy.setApplicationProxy(proxy)
# In order to make Python able to handle signals
force_python_execution = QTimer()
force_python_execution.start(200)
def ignore():
pass
force_python_execution.timeout.connect(ignore)
web = WebBrowser(cfg.auto_fill_rules, self._states.put)
startup_info = self._commands.get()
logger.info("Browser started", startup_info=startup_info)
logger.info("Loading page", url=startup_info.url)
web.authenticate_at(QUrl(startup_info.url), startup_info.credentials)
web.show()
rc = app.exec_()
logger.info("Exiting browser")
return rc
def setProxy(self, enable, hostname, port, username, password):
proxy = QNetworkProxy()
if enable:
proxy.setType(QNetworkProxy.HttpProxy)
print("启动代理")
print("主机名", hostname)
print("端口", port)
print("用户名", username)
print("密码", password)
else:
proxy.setType(QNetworkProxy.NoProxy)
print("取消代理")
proxy.setHostName(hostname)
proxy.setPort(port)
proxy.setUser(username)
proxy.setPassword(password)
QNetworkProxy.setApplicationProxy(proxy)
def run(self):
current_thread().name = "WebKit"
# signal.signal(signal.SIGINT, signal.SIG_DFL)
app = QApplication([])
signal.signal(signal.SIGINT, self.onExit)
signal.signal(signal.SIGINT, signal.SIG_DFL)
# Helps to handle Ctrl+C action.
self.timer = QTimer()
self.timer.start(1000)
self.timer.timeout.connect(lambda: None)
# Setup proxy for browser elements.
if self.proxy is not None:
url, port = self.proxy.split(":")
proxy = QNetworkProxy()
proxy.setType(QNetworkProxy.HttpProxy)
proxy.setHostName(url)
proxy.setPort(int(port))
QNetworkProxy.setApplicationProxy(proxy)
for i in range(self.poolsize):
renderer = WebPage()
renderer._pipequeue = self._pipequeue
self._pool.append(renderer)
# Hmm... QThread blocks GUI, this, python one not blocks.
self.sidethread = SideThread(self)
self.sidethread.daemon = True
self.sidethread.start()
# Load GUI if it's needed.
if self.gui:
self.mv = MainWindow()
self.mv.show()
for web in self._pool:
view = QWebEngineView()
view.setPage(web)
self.mv.addTab(view, web.title())
app.exec_()
