class MainWidow(QWidget):
def __init__(self):
super().__init__()
self.view=QWebEngineView()
self.myprofile=self.getProfile()
self.page=QWebEnginePage(self.myprofile,None)
# self.channel=QWebChannel()
# self.myobject=myObject()
# self.channel.registerObject("xdpy", self.myobject)
# self.page.setWebChannel(self.channel)
self.page.settings().AllowRunningInsecureContent=True;
self.page.settings().JavascriptEnabled=True;
self.view.page=self.page
self.url=QUrl("")
self.view.page.load(self.url)
self.view.show()
self.view.settings().JavascriptEnabled=True
def js_callback(self,result):
print("js_callback:{}".format(result))
def injectJS(self,sourceCode,name):
script = QWebEngineScript();
script.setSourceCode(sourceCode)
script.setName(name)
script.setInjectionPoint(QWebEngineScript.DocumentCreation)
script.setWorldId(QWebEngineScript.MainWorld)
script.setRunsOnSubFrames(True)
self.view.page.scripts().insert(script)
self.page.scripts().insert(script)
def getProfile(self):
profile=QWebEngineProfile("myProfile")
profile.cachePath="/home/yyk/Desktop/cache"
jsFile = constants.QTWEBCHANNELJS_FILE
with open(jsFile, encoding="UTF-8") as file:
js = file.read()
script = QWebEngineScript();
script.setSourceCode(js)
script.setName('qwebchannel.js')
script.setInjectionPoint(QWebEngineScript.DocumentCreation)
script.setWorldId(QWebEngineScript.MainWorld)
script.setRunsOnSubFrames(False)
profile.scripts().insert(script)
return profile
def __init__(self):
super().__init__()
self.view=QWebEngineView()
self.myprofile=self.getProfile()
self.page=QWebEnginePage(self.myprofile,None)
# self.channel=QWebChannel()
# self.myobject=myObject()
# self.channel.registerObject("xdpy", self.myobject)
# self.page.setWebChannel(self.channel)
self.page.settings().AllowRunningInsecureContent=True;
self.page.settings().JavascriptEnabled=True;
self.view.page=self.page
self.url=QUrl("")
self.view.page.load(self.url)
self.view.show()
self.view.settings().JavascriptEnabled=True
def load(self, url):
if not isinstance(url, QUrl):
url = QUrl.fromUserInput(url)
self.__delay_loading_url = None
return QWebEnginePage.load(self, url)
class RequestWidget(QWidget):
def __init__(self, parent, keyList, request=None):
super().__init__(parent)
self.keyList = keyList
# INITIALIZE POLYGON MANAGEMENT
self.polygonSettings = []
self.polygonActivated = False
self.html = ""
self.webChannel = QWebChannel()
self.webChannel.registerObject('request', self)
self.polygonPage = QWebEnginePage()
self.polygonPage.setWebChannel(self.webChannel)
# INITIALIZE UI
self.layout = self.__generateLayout__()
self.setLayout(self.layout)
elementsTypeGB, self.nodesCB, self.waysCB, self.relCB, self.areasCB = self.__generateTypeWidget__()
self.layout.addRow("ELEMENTS TYPE", elementsTypeGB)
self.layout.addRow(HorizontalLine(self))
self.locationNameWidget = self.__generateLocationWidget__()
self.layout.addRow("LOCATION", self.locationNameWidget)
self.layout.addRow(HorizontalLine(self))
filtersButtons, self.filtersWidget, self.filtersLayout = self.__generateFiltersWidget__()
self.layout.addRow("FILTERS", filtersButtons)
self.layout.addRow(self.filtersWidget)
self.layout.addRow(HorizontalLine(self))
polygonButtons = self.__generatePolygonWidget__()
self.layout.addRow("POLYGON", polygonButtons)
self.layout.addRow(HorizontalLine(self))
self.surroundGB, self.aroundRadiusEdit = self.__generateSurroundingWidget__()
self.layout.addRow("SURROUNDINGS", self.surroundGB)
self.layout.addRow(HorizontalLine(self))
self.idsWidget = self.__generateIdsWidget__()
self.layout.addRow("IDS", self.idsWidget)
# SETTING DATA
if request is None:
self.requestName = SetNameManagement.getUniqueSetName()
else:
self.__setRequest__(request)
# UI COMPONENTS
def __generateLayout__(self):
layout = QFormLayout()
layout.setContentsMargins(10, 10, 10, 10)
layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
layout.setLabelAlignment(Qt.AlignLeft)
layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
return layout
def __generateLocationWidget__(self):
locationNameWidget = QLineEdit()
locationNameWidget.setPlaceholderText("Areas: 'New York', 'Italy'...")
locationNameWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
return locationNameWidget
def __generatePolygonWidget__(self):
return WidgetFactory.buildIconButtonGroup([
{"image": "polygon.png", "tooltip": "Draw polygon", "checkable": True, "action": self.enableDisablePolygon},
{"image": "reset.png", "tooltip": "Remove polygon", "checkable": False, "action": self.clearPolygon}
])
def __generateTypeWidget__(self):
elementsTypeGB = QWidget()
elementsTypeLayout = QVBoxLayout()
elementsTypeGB.setLayout(elementsTypeLayout)
elementsTypeLayout.setContentsMargins(10, 0, 0, 0)
elementsTypeLayout.setSpacing(0)
nodesCB = QCheckBox(self.tr("&Nodes"))
elementsTypeLayout.addWidget(nodesCB)
waysCB = QCheckBox(self.tr("&Ways"))
waysCB.setChecked(True)
elementsTypeLayout.addWidget(waysCB)
relCB = QCheckBox(self.tr("&Relations"))
elementsTypeLayout.addWidget(relCB)
areasCB = QCheckBox(self.tr("&Areas"))
areasCB.stateChanged.connect(self.__onAreaSelected__)
elementsTypeLayout.addWidget(areasCB)
nodesCB.stateChanged.connect(lambda b: self.areasCB.setChecked(False) if b else None)
waysCB.stateChanged.connect(lambda b: self.areasCB.setChecked(False) if b else None)
relCB.stateChanged.connect(lambda b: self.areasCB.setChecked(False) if b else None)
return elementsTypeGB, nodesCB, waysCB, relCB, areasCB
def __generateSurroundingWidget__(self):
surroundGB = QGroupBox()
surroundGB.setFlat(True)
surroundLayout = QVBoxLayout()
surroundLayout.setContentsMargins(0, 0, 0, 0)
noneRB = QRadioButton(self.tr("&None"))
noneRB.setObjectName("None")
noneRB.setChecked(True)
surroundLayout.addWidget(noneRB)
adjacentRB = QRadioButton(self.tr("&Adjacent streets"))
adjacentRB.setObjectName("Adjacent")
surroundLayout.addWidget(adjacentRB)
aroundRB = QRadioButton(self.tr("&Streets around"))
aroundRB.setObjectName("Around")
surroundLayout.addWidget(aroundRB)
aroundRadiusEdit = QLineEdit("")
aroundRadiusEdit.hide()
aroundRadiusEdit.setPlaceholderText("Radius in meters")
aroundRadiusEdit.setValidator(QIntValidator(0, 10000000, surroundGB))
aroundRB.toggled.connect(lambda b: aroundRadiusEdit.show() if b else aroundRadiusEdit.hide())
surroundLayout.addWidget(aroundRadiusEdit)
surroundGB.setLayout(surroundLayout)
return surroundGB, aroundRadiusEdit
def __generateFiltersWidget__(self):
filtersButtons = QWidget()
filtersButtonsLayout = QHBoxLayout()
filtersButtons.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
filtersButtonsLayout.setAlignment(Qt.AlignRight)
filtersButtonsLayout.setSpacing(0)
filtersButtonsLayout.setContentsMargins(0, 0, 0, 0)
filtersButtons.setLayout(filtersButtonsLayout)
addFilterButton = IconButton(QIcon(os.path.join(picturesDir, "add.png")),
filtersButtons.windowHandle(),
filtersButtons.height())
addFilterButton.setToolTip("Add filter")
addFilterButton.setFlat(True)
addFilterButton.setStyleSheet("""QPushButton::menu-indicator{image: none;}""")
filtersMenu = QMenu()
equalAct = QAction('Equal', self)
equalAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.EQUAL))
filtersMenu.addAction(equalAct)
maxAct = QAction('Maximum', self)
maxAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.AT_MOST))
filtersMenu.addAction(maxAct)
minAct = QAction('Minimum', self)
minAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.AT_LEAST))
filtersMenu.addAction(minAct)
containAllAct = QAction('Contain all', self)
containAllAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.CONTAIN_ALL))
filtersMenu.addAction(containAllAct)
oneOfAct = QAction('Is one of', self)
oneOfAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.IS_ONE_OF))
filtersMenu.addAction(oneOfAct)
hasKeyAct = QAction('Has key', self)
hasKeyAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.HAS_KEY))
filtersMenu.addAction(hasKeyAct)
hasOneKeyAct = QAction('Has one key', self)
hasOneKeyAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.HAS_ONE_KEY))
filtersMenu.addAction(hasOneKeyAct)
hasNotKeyAct = QAction('Has not key', self)
hasNotKeyAct.triggered.connect(lambda: self.addFilterByComparison(comparison=TagComparison.HAS_NOT_KEY))
filtersMenu.addAction(hasNotKeyAct)
addFilterButton.setMenu(filtersMenu)
filtersButtonsLayout.addWidget(addFilterButton)
filtersWidget = QWidget(self)
filtersLayout = QVBoxLayout()
filtersLayout.setContentsMargins(10, 10, 10, 10)
filtersWidget.setLayout(filtersLayout)
return filtersButtons, filtersWidget, filtersLayout
def __generateIdsWidget__(self):
return VariableInputList(0, "Numeric id", QRegularExpressionValidator(QRegularExpression("^[0-9]+$")))
# REQUEST GETTERS
def __getLocationName__(self):
return self.locationNameWidget.text()
def __getType__(self):
return OsmType.getType(self.nodesCB.isChecked(), self.waysCB.isChecked(),
self.relCB.isChecked(), self.areasCB.isChecked())
def __getSelectedSurrounding__(self):
switcher = {
"Adjacent": Surround.ADJACENT,
"Around": Surround.AROUND,
"None": Surround.NONE
}
selectedSurrounding = [b for b in self.surroundGB.findChildren(QRadioButton) if b.isChecked()][0]
return switcher.get(selectedSurrounding.objectName())
@pyqtSlot(QJsonValue)
def __setPolygons__(self, val):
self.polygonSettings = []
for point in val.toArray():
self.polygonSettings.append([point["lat"].toDouble(), point["lng"].toDouble()])
def __getPolygon__(self):
return self.polygonSettings
def getAroundRadius(self):
return int(self.aroundRadiusEdit.text()) if len(self.aroundRadiusEdit.text()) > 0 else 100
def getRequest(self):
request = OverpassRequest(self.__getType__(),
self.__getSelectedSurrounding__(),
self.requestName,
self.getAroundRadius())
request.setLocationName(self.__getLocationName__())
if request.locationId is None and request.locationName != "":
logging.warning("Location name not found in the request '{}'. It will be ignored.".format(self.requestName))
request.addPolygon(self.__getPolygon__())
request.setIds(self.__getIds__())
for filterWidget in self.filtersWidget.findChildren(FilterWidget):
try:
request.addFilter(filterWidget.getFilter())
except BadFilterAttributes as e:
raise BadFilterAttributes("Error in one of the filters of request '{}'. {}".format(self.requestName, str(e)))
return request
def getName(self):
return self.requestName
def getMap(self):
return self.polygonPage
def __getIds__(self):
return self.idsWidget.getItems()
# REQUEST SETTERS
def addFilterByComparison(self, comparison):
newFilterWidget = FilterWidget(self.filtersWidget, comparison, self.keyList)
self.filtersLayout.addWidget(newFilterWidget)
def addFilter(self, filter):
currentKeys = {filter.getKey(): filter for filter in self.findChildren(FilterWidget)}
if filter.key != "" and filter.key in currentKeys.keys():
logging.warning("The key {} is used more than once in the set {}.".format(filter.key, self.getName()))
newFilterWidget = FilterWidget(self.filtersWidget, filter.comparison, self.keyList)
self.filtersLayout.addWidget(newFilterWidget)
newFilterWidget.setFilter(filter)
def __setLocationName__(self, locationName):
self.locationNameWidget.setText(locationName)
def __setType__(self, requestType):
typeConfig = OsmType.getConfig(requestType)
self.waysCB.setChecked(typeConfig["way"])
self.nodesCB.setChecked(typeConfig["node"])
self.relCB.setChecked(typeConfig["rel"])
self.areasCB.setChecked(typeConfig["area"])
def __setSelectedSurrounding__(self, surroundValue):
if surroundValue == Surround.ADJACENT:
self.surroundGB.findChild(QRadioButton, "Adjacent").setChecked(True)
elif surroundValue == Surround.AROUND:
self.surroundGB.findChild(QRadioButton, "Around").setChecked(True)
elif surroundValue == Surround.NONE:
self.surroundGB.findChild(QRadioButton, "None").setChecked(True)
def changePolygon(self, coors):
self.polygonSettings = coors
if self.html != "":
self.changePage(self.html)
def setAroundRadius(self, radius):
return self.aroundRadiusEdit.setText(str(radius))
def __setRequest__(self, request):
self.requestName = request.name
self.__setType__(request.type)
self.setAroundRadius(request.aroundRadius)
self.__setSelectedSurrounding__(request.surrounding)
for filterWidget in self.filtersWidget.findChildren(FilterWidget):
filterWidget.deleteLater()
for filter in request.filters:
self.addFilter(filter)
self.__setLocationName__(request.locationName)
self.setIds(request.ids)
self.changePolygon(request.polygon)
def changePage(self, html):
self.html = html
soup = bs4.BeautifulSoup(html, features="html.parser")
js = soup.new_tag("script")
js.string = (JS_SCRIPT % (str(self.polygonSettings), str(self.polygonActivated).lower()))
soup.append(js)
soup.head.append(soup.new_tag("script", src="qrc:///qtwebchannel/qwebchannel.js"))
htmlFileName = os.path.join(tempDir, "{}.html".format(self.requestName))
with open(htmlFileName, "w+") as f:
f.write(str(soup))
self.polygonPage.load(QUrl.fromLocalFile(htmlFileName))
def setIds(self, ids=None):
self.idsWidget.setItems(ids)
def addId(self, newId=0):
self.idsWidget.addItem(newId)
def __del__(self):
SetNameManagement.releaseName(self.requestName)
# SIGNALS
def __onAreaSelected__(self):
self.nodesCB.setChecked(False)
self.waysCB.setChecked(False)
self.relCB.setChecked(False)
def clearPolygon(self):
self.polygonPage.runJavaScript("cleanPolygon();", lambda x: logging.debug("LINE"))
def enableDisablePolygon(self, checked):
self.polygonActivated = checked
self.polygonPage.runJavaScript("enablePolygon();" if checked else "disablePolygon();")
class AuthWidget(QWebEngineView):
config = None
config_file = DEFAULT_CONFIG_FILE
credential = DEFAULT_CREDENTIAL
credential_file = None
auth_url = None
authn_session = None
authn_session_page = None
authn_cookie_name = None
authn_expires = time.time()
cookie_persistence = False
_success_callback = None
_session = requests.session()
token = None
def __init__(self,
parent,
config=None,
credential_file=None,
cookie_persistence=False):
super(AuthWidget, self).__init__(parent)
self.cookie_persistence = cookie_persistence
self._timer = QTimer(self)
self._timer.timeout.connect(self._onTimerFired)
self.configure(config, credential_file)
info = "%s v%s [Python %s, %s]" % (self.__class__.__name__, VERSION,
platform.python_version(),
platform.platform(aliased=True))
logging.info("Initializing authorization provider: %s" % info)
# logging.getLogger().setLevel(logging.TRACE)
def configure(self, config, credential_file):
self.config = config if config else read_config(
self.config_file, create_default=True, default=DEFAULT_CONFIG)
self.credential_file = credential_file
host = self.config.get("host")
if not host:
self.setHtml(
ERROR_HTML %
"Could not locate hostname parameter in configuration.")
return
self.auth_url = QUrl()
self.auth_url.setScheme(config.get("protocol", "https"))
self.auth_url.setHost(host)
if config.get("port") is not None:
self.auth_url.setPort(config["port"])
self.authn_cookie_name = self.config.get("cookie_name", "webauthn")
retries = Retry(
connect=DEFAULT_SESSION_CONFIG['retry_connect'],
read=DEFAULT_SESSION_CONFIG['retry_read'],
backoff_factor=DEFAULT_SESSION_CONFIG['retry_backoff_factor'],
status_forcelist=DEFAULT_SESSION_CONFIG['retry_status_forcelist'])
self._session.mount(self.auth_url.toString() + '/',
HTTPAdapter(max_retries=retries))
def authenticated(self):
if self.authn_session is None:
return False
now = time.time()
if now >= self.authn_expires:
return False
return True
def login(self):
if not (self.auth_url and
(self.auth_url.host() and self.auth_url.scheme())):
logging.error(
"Missing or invalid hostname parameter in configuration.")
return
logging.info("Authenticating with host: %s" % self.auth_url.toString())
qApp.setOverrideCursor(Qt.WaitCursor)
self._cleanup()
self.setHtml(DEFAULT_HTML)
self.authn_session_page = \
QWebEnginePage(QWebEngineProfile(self), self) if not self.cookie_persistence else QWebEnginePage(self)
self.authn_session_page.loadProgress.connect(self._onLoadProgress)
self.authn_session_page.loadFinished.connect(self._onLoadFinished)
self.authn_session_page.profile().cookieStore().cookieAdded.connect(
self._onCookieAdded)
self.authn_session_page.profile().cookieStore().cookieRemoved.connect(
self._onCookieRemoved)
self.authn_session_page.setUrl(
QUrl(self.auth_url.toString() + "/authn/preauth"))
def logout(self, delete_cookies=False):
if not (self.auth_url and
(self.auth_url.host() and self.auth_url.scheme())):
return
if not self.authenticated():
return
try:
logging.info("Logging out of host: %s" % self.auth_url.toString())
if delete_cookies and self.cookie_persistence:
self.authn_session_page.profile().cookieStore(
).deleteAllCookies()
self._session.delete(self.auth_url.toString() + "/authn/session")
except Exception as e:
logging.warning("Logout error: %s" % format_exception(e))
self._cleanup()
def setSuccessCallback(self, callback=None):
self._success_callback = callback
def setStatus(self, message):
if self.window().statusBar is not None:
self.window().statusBar().showMessage(message)
def _execSuccessCallback(self):
if self._success_callback:
self._success_callback(host=self.auth_url.host(),
credential=self.credential)
def _onTimerFired(self):
if not self.authenticated():
self.authn_session = None
return
resp = self._session.put(self.auth_url.toString() + "/authn/session")
seconds_remaining = self.authn_session['seconds_remaining']
self.authn_expires = time.time() + seconds_remaining + 1
if resp.ok:
logging.trace("webauthn session:\n%s\n", resp.json())
logging.info("Session refreshed for: %s" % self.auth_url.host())
else:
logging.warning(
"Unable to refresh session for: %s. Server responded: %s" %
(self.auth_url.host(),
str.format(
"%s %s: %s" %
(resp.status_code, resp.reason, resp.content.decode()))))
def _onSessionContent(self, content):
try:
self.setHtml(SUCCESS_HTML)
self.authn_session = json.loads(content)
seconds_remaining = self.authn_session['seconds_remaining']
if not self._timer.isActive():
interval = seconds_remaining // 2
logging.info(
"Authentication successful for [%s]: credential refresh in %d seconds."
% (self.auth_url.toString(), interval))
self._timer.start(interval * 1000)
self.authn_expires = time.time() + seconds_remaining + 1
logging.trace("webauthn session:\n%s\n",
json.dumps(self.authn_session, indent=2))
qApp.restoreOverrideCursor()
QTimer.singleShot(100, self._execSuccessCallback)
except (ValueError, Exception) as e:
logging.error(format_exception(e))
self.setHtml(ERROR_HTML % content)
def _onPreAuthContent(self, content):
try:
if not content:
logging.debug("no preauth content")
return
preauth = json.loads(content)
logging.trace("webauthn preauth:\n%s\n",
json.dumps(preauth, indent=2))
qApp.setOverrideCursor(Qt.WaitCursor)
self.authn_session_page.setUrl(QUrl(preauth["redirect_url"]))
except (ValueError, Exception) as e:
logging.error(format_exception(e))
self.setHtml(ERROR_HTML % content)
def _onLoadFinished(self, result):
qApp.restoreOverrideCursor()
if not result:
logging.debug("Page load error: %s" %
self.authn_session_page.url().toDisplayString())
self.setPage(self.authn_session_page)
return
if self.authn_session_page.url().path() == "/authn/preauth":
self.authn_session_page.toPlainText(self._onPreAuthContent)
elif self.authn_session_page.url().path() == "/authn/session":
self.authn_session_page.toPlainText(self._onSessionContent)
else:
self.setPage(self.authn_session_page)
def _onLoadProgress(self, progress):
self.setStatus("Loading page: %s [%d%%]" %
(self.url().host(), progress))
def _onCookieAdded(self, cookie):
cookie_str = str(cookie.toRawForm(QNetworkCookie.NameAndValueOnly),
encoding='utf-8')
cookie_name = str(cookie.name(), encoding='utf-8')
cookie_val = str(cookie.value(), encoding='utf-8')
if (cookie_name
== self.authn_cookie_name) and (cookie.domain()
== self.config.get("host")):
logging.trace("%s cookie added:\n\n%s\n\n" %
(self.authn_cookie_name, cookie_str))
self.credential["cookie"] = "%s=%s" % (self.authn_cookie_name,
cookie_val)
host = self.auth_url.host()
cred_entry = dict()
cred_entry[host] = self.credential
if self.credential_file:
creds = read_credential(self.credential_file,
create_default=True)
creds.update(cred_entry)
write_credential(self.credential_file, creds)
self.token = cookie_val
self._session.cookies.set(self.authn_cookie_name,
cookie_val,
domain=host,
path='/')
self.authn_session_page.setUrl(
QUrl(self.auth_url.toString() + "/authn/session"))
def _onCookieRemoved(self, cookie):
cookie_str = str(cookie.toRawForm(QNetworkCookie.NameAndValueOnly),
encoding='utf-8')
cookie_name = str(cookie.name(), encoding='utf-8')
if cookie_name == self.authn_cookie_name and cookie.domain(
) == self.url().host():
logging.trace("%s cookie removed:\n\n%s\n\n" %
(self.authn_cookie_name, cookie_str))
def _cleanup(self):
self._timer.stop()
self.token = None
self.authn_session = None
self.authn_expires = time.time()
if self.authn_session_page:
self.authn_session_page.loadProgress.disconnect(
self._onLoadProgress)
self.authn_session_page.loadFinished.disconnect(
self._onLoadFinished)
self.authn_session_page.profile().cookieStore(
).cookieAdded.disconnect(self._onCookieAdded)
self.authn_session_page.profile().cookieStore(
).cookieRemoved.disconnect(self._onCookieRemoved)
del self.authn_session_page
def title(self):
if self.__delay_loading_url:
return self.__delay_loading_url.title
return QWebEnginePage.title(self)
def createWindow(self, t):
fake_page = QWebEnginePage(self)
fake_page.urlChanged.connect(
lambda url: self.__create_window_request(fake_page, url))
return fake_page
def test_qt(self):
from PyQt5.QtCore import QTimer
from PyQt5.QtWidgets import QApplication
from PyQt5.QtWebEngineWidgets import QWebEnginePage
from PyQt5.QtGui import QImageReader, QFontDatabase
from PyQt5.QtNetwork import QNetworkAccessManager
from calibre.utils.img import image_from_data, image_to_data, test
# Ensure that images can be read before QApplication is constructed.
# Note that this requires QCoreApplication.libraryPaths() to return the
# path to the Qt plugins which it always does in the frozen build,
# because Qt is patched to know the layout of the calibre application
# package. On non-frozen builds, it should just work because the
# hard-coded paths of the Qt installation should work. If they do not,
# then it is a distro problem.
fmts = set(
map(lambda x: x.data().decode('utf-8'),
QImageReader.supportedImageFormats())) # no2to3
testf = {'jpg', 'png', 'svg', 'ico', 'gif'}
self.assertEqual(
testf.intersection(fmts), testf,
"Qt doesn't seem to be able to load some of its image plugins. Available plugins: %s"
% fmts)
data = P('images/blank.png', allow_user_override=False, data=True)
img = image_from_data(data)
image_from_data(
P('catalog/mastheadImage.gif',
allow_user_override=False,
data=True))
for fmt in 'png bmp jpeg'.split():
d = image_to_data(img, fmt=fmt)
image_from_data(d)
# Run the imaging tests
test()
from calibre.gui2 import ensure_app, destroy_app
display_env_var = os.environ.pop('DISPLAY', None)
try:
ensure_app()
self.assertGreaterEqual(
len(QFontDatabase().families()), 5,
'The QPA headless plugin is not able to locate enough system fonts via fontconfig'
)
from calibre.ebooks.covers import create_cover
create_cover('xxx', ['yyy'])
na = QNetworkAccessManager()
self.assertTrue(hasattr(na, 'sslErrors'),
'Qt not compiled with openssl')
if iswindows:
from PyQt5.Qt import QtWin
QtWin
p = QWebEnginePage()
def callback(result):
callback.result = result
if hasattr(print_callback, 'result'):
QApplication.instance().quit()
def print_callback(result):
print_callback.result = result
if hasattr(callback, 'result'):
QApplication.instance().quit()
p.runJavaScript('1 + 1', callback)
p.printToPdf(print_callback)
QTimer.singleShot(5000, lambda: QApplication.instance().quit())
QApplication.instance().exec_()
test_flaky = ismacos and not is_ci
if not test_flaky:
self.assertEqual(callback.result, 2,
'Simple JS computation failed')
self.assertIn(b'Skia/PDF', bytes(print_callback.result),
'Print to PDF failed')
del p
del na
destroy_app()
del QWebEnginePage
finally:
if display_env_var is not None:
os.environ['DISPLAY'] = display_env_var
from qutebrowser.config import config
from qutebrowser.utils import log, debug, usertypes
_QB_FILESELECTION_MODES = {
QWebEnginePage.FileSelectOpen:
shared.FileSelectionMode.single_file,
QWebEnginePage.FileSelectOpenMultiple:
shared.FileSelectionMode.multiple_files,
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-91489
#
# QtWebEngine doesn't expose this value from its internal
# FilePickerControllerPrivate::FileChooserMode enum (i.e. it's not included in
# the public QWebEnginePage::FileSelectionMode enum).
# However, QWebEnginePage::chooseFiles is still called with the matching value
# (2) when a file input with "webkitdirectory" is used.
QWebEnginePage.FileSelectionMode(2):
shared.FileSelectionMode.folder,
}
class WebEngineView(QWebEngineView):
"""Custom QWebEngineView subclass with qutebrowser-specific features."""
def __init__(self, *, tabdata, win_id, private, parent=None):
super().__init__(parent)
self._win_id = win_id
self._tabdata = tabdata
theme_color = self.style().standardPalette().color(QPalette.Base)
if private:
assert webenginesettings.private_profile is not None
profile = webenginesettings.private_profile
def __init__(self, url):
QWebEnginePage.__init__(self)
self.html = ''
self.loadFinished.connect(self._on_load_finished)
self.load(QUrl(url))
self.app.exec_()
class TestForm(QMainWindow, Ui_MainWindow):
#생성자
def __init__(self):
super().__init__()
self.setupUi(self) # 초기화
self.url = QUrl("http://localhost:8080/umbrella")
self.webEngineView.load(QUrl(self.url))
self.page = QWebEnginePage()
self.page.setUrl(self.url)
self.page.setView(self.webEngineView)
self.comboBox.addItem("키워드")
self.comboBox.addItem("주소")
# self.page.featurePermissionRequested.connect(self.setPagePermission)
self.pushButton.clicked.connect(self.search)
self.lineEdit.returnPressed.connect(self.search)
self.init_my_location()
self.page.loadFinished.connect(
lambda: self.setMap(self.my_location_lat, self.my_location_lng))
# self.setMap(self.my_location_lat, self.my_location_lng)
#아이피로 현재 위치 받아오기(google api 사용)
def init_my_location(self):
url = 'https://www.googleapis.com/geolocation/v1/geolocate?key=AIzaSyDQKxbTt0MrFNH85kTJXzickMD5s88UVaI'
data = {
'considerIp': True,
}
result = requests.post(url, data)
my_location = json.loads(result.text)
# print(my_location)
print("lat : ", my_location.get('location').get('lat'))
print("lon : ", my_location.get('location').get('lng'))
self.my_location_lat = my_location.get('location').get('lat')
self.my_location_lng = my_location.get('location').get('lng')
def setMap(self, lat, lng):
script = """
var umbrella_location = new kakao.maps.LatLng(""" + str(
lat) + """, """ + str(lng) + """);
map.setCenter(umbrella_location);
"""
self.run(script)
#위치권한 요청이 왔을때 허용해줌
def setPagePermission(self, url, feature):
self.page.setFeaturePermission(url, feature,
QWebEnginePage.PermissionGrantedByUser)
def search(self):
search_text = self.lineEdit.text().strip()
if self.comboBox.currentIndex() == 0:
script = """
removeMarkers();
// 주소-좌표 변환 객체를 생성합니다
var geocoder = new kakao.maps.services.Geocoder();
// 장소 검색 객체를 생성합니다
var ps = new kakao.maps.services.Places();
// 키워드로 장소를 검색합니다
ps.keywordSearch('""" + search_text + """', placesSearchCB);
function placesSearchCB (data, status, pagination) {
if (status === kakao.maps.services.Status.OK) {
// 검색된 장소 위치를 기준으로 지도 범위를 재설정하기위해
// LatLngBounds 객체에 좌표를 추가합니다
var bounds = new kakao.maps.LatLngBounds();
for (var i=0; i<data.length; i++) {
displayMarker(data[i]);
bounds.extend(new kakao.maps.LatLng(data[i].y, data[i].x));
}
// 검색된 장소 위치를 기준으로 지도 범위를 재설정합니다
map.setBounds(bounds);
}
}
"""
elif self.comboBox.currentIndex():
script = """
removeMarkers();
var positions = [];
positions=Marker3.main3();
for (var i=0; i<positions.length;i++){
map:map,
position:new kakao.maps.LatLng(positions[i].get('lat')+positions[i].get('lng'))
}
// 주소-좌표 변환 객체를 생성합니다
var geocoder = new kakao.maps.services.Geocoder();
// 주소로 좌표를 검색합니다
geocoder.addressSearch('""" + search_text + """', function(result, status) {
// 정상적으로 검색이 완료됐으면
if (status === kakao.maps.services.Status.OK) {
var coords = new kakao.maps.LatLng(result[0].y, result[0].x);
// 결과값으로 받은 위치를 마커로 표시합니다
var marker = new kakao.maps.Marker({
map: map,
position: coords
});
//*** 마커 담기
markerList.push(marker)
// 인포윈도우로 장소에 대한 설명을 표시합니다
infowindow.open(map, marker);
// 지도의 중심을 결과값으로 받은 위치로 이동시킵니다
map.setCenter(coords);
}
}); """
else:
return
self.run(script)
def run(self, script):
self.page.runJavaScript(script)
logging_kwargs = {}
if args.logfile != "":
logging_kwargs["filename"] = args.logfile
logging.basicConfig(level=getattr(logging, args.logLevel), **logging_kwargs)
log.debug("starting subprocess")
log.debug("args: " + repr(args))
app = QApplication([])
browser = QWebEngineView()
if args.storage != "":
log.debug("using storage " + args.storage)
profile = QWebEngineProfile(args.storage, browser)
webpage = QWebEnginePage(profile, browser)
browser.setPage(webpage)
redirect_uri = args.redirect_uri
def parse_token(url_with_token):
qsl = parse_qsl(url_with_token.split("#", 1)[1])
token = {}
for el in qsl:
token[el[0]] = el[1]
return token
def token_getter_url(**kwargs):
return "https://oauth.vk.com/authorize?" + urlencode(kwargs)
def acceptNavigationRequest(self, url, type_, bool_):
if self.delegate_links and type_ == self.NavigationTypeLinkClicked and url.url().startswith("om://"):
LOGGER.debug("acceptNavigationRequest %s", url)
self.parent().linkClicked.emit(url)
return False
return QWebEnginePage.acceptNavigationRequest(self, url, type_, bool_)
class Browser(QMainWindow):
def __init__(self, mainWin, webview=None):
super().__init__(mainWin)
self.showFullScreen()
self.mainWin = mainWin
self.webview = webview
self.initUI()
def initUI(self):
global CREATE_BROWER
# print("initUI")
# self.setWindowFlags(Qt.FramelessWindowHint) # 去掉标题栏的代码
# 设置窗口标题
# self.setWindowTitle('LingBrowser')
# 设置窗口图标
self.setWindowIcon(QIcon(':/icons/logo.png'))
self.page = QWebEnginePage()
self.page.settings().setAttribute(QWebEngineSettings.PluginsEnabled, True) # 支持视频播放
self.page.settings().setAttribute(QWebEngineSettings.JavascriptEnabled, True)
self.page.settings().setAttribute(QWebEngineSettings.FullScreenSupportEnabled, True)
if self.webview == None:
# 初始化一个 tab
self.webview = WebView(self) # self必须要有，是将主窗口作为参数，传给浏览器
self.page.setUrl(QUrl(HOME_PAGE))
self.page.windowCloseRequested.connect(self.on_windowCloseRequested) # 页面关闭请求
if CREATE_BROWER:
CREATE_BROWER = False
self.page.profile().downloadRequested.connect(self.on_downloadRequested) # 页面下载请求
self.t = WebEngineUrlRequestInterceptor()
self.page.profile().setRequestInterceptor(self.t)
self.webview.setPage(self.page)
self.url = self.webview.page().url()
self.initToolbar(self.webview)
self.setCentralWidget(self.webview)
self.center()
def on_downloadRequested(self, downloadItem):
# print("download..")
# print(downloadItem.downloadFileName())
# print('isFinished', downloadItem.isFinished())
# print('isPaused', downloadItem.isPaused())
# print('isSavePageDownload', downloadItem.isSavePageDownload())
# print('path', downloadItem.path())
# print('url', downloadItem.url())
downloadFileName, ok2 = QFileDialog.getSaveFileName(self,
"文件保存",
downloadItem.path(),
"All Files (*)")
print(downloadItem.path())
downloadItem.setPath(downloadFileName)
downloadItem.accept()
downloadItem.finished.connect(self.on_downloadfinished)
downloadItem.downloadProgress.connect(self.on_downloadProgress)
def on_downloadfinished(self):
print()
def on_downloadProgress(self, int_1, int_2):
rate = str(round(int_1 / int_2, 2) * 100).split(".")[0]
self.mainWin.statusBarDownloadLabel.setText("文件下载 " + rate + "%")
if int(rate) == 100:
self.mainWin.statusBarDownloadLabel.setHidden(True)
self.mainWin.statusBar.setHidden(True)
else:
self.mainWin.statusBarDownloadLabel.setHidden(False)
self.mainWin.statusBar.setHidden(False)
def on_windowCloseRequested(self):
print("close tab")
# self.webview.close()
# del self.webview
# sip.delete(self.webview)
# self.webview
# self.webview.page().profile().deleteLater()
# self.deleteLater()
pass
def moreMenuShow(self):
try:
self.contextMenu = QMenu()
self.contextMenu.setObjectName("moreMenu")
self.contextMenu.setFont(fontawesome("far"))
# self.actionA = self.contextMenu.addAction(self.zoom_in_action)
# self.actionA = self.contextMenu.addAction(self.zoom_out_action)
self.contextMenu.popup(
QPoint(self.mainWin.x() + self.more_button.x() - 200, self.mainWin.y() + 75)) # 2菜单显示的位置 QCursor.pos()
# print(self.more_button.x())
# print(self.more_button.y())
# print(self.frameGeometry())
# print(self.mainWin.x())
# print(self.mainWin.y())
self.contextMenu.setContentsMargins(25,0,0,0)
self.contextMenu.addMenu("打印")
self.contextMenu.addSeparator()
# 缩放组合
sf_widget = QWidget(self)
sf_widget.setProperty("class","qwidget")
sf_widget.setObjectName("sf_widget")
sf_widget.setContentsMargins(0,0,0,0)
# sf_widget.setFixedHeight(20)
sf_layout = QHBoxLayout()
sf_layout.setContentsMargins(0,0,0,0)
sf_widget.setLayout(sf_layout)
sf_label = QLabel("缩放")
sf_label.setObjectName("sf_item_label")
sf_layout.addWidget(sf_label)
sf_layout.addWidget(self.zoom_out_button)
sf_layout.addWidget(self.sf_label_rate)
sf_layout.addWidget(self.zoom_in_button)
sf_layout.addWidget(self.full_screen_button)
sf_action = QWidgetAction(self)
sf_action.setDefaultWidget(sf_widget)
self.actionA = self.contextMenu.addAction(sf_action)
# self.actionA.triggered.connect(self.actionHandler)
sf_layout.setSpacing(0)
self.contextMenu.show()
except Exception as e:
print(e)
def initToolbar(self, webview):
pass
###使用QToolBar创建导航栏，并使用QAction创建按钮
# 添加导航栏
self.navigation_bar = QToolBar('Navigation')
# 锁定导航栏
self.navigation_bar.setMovable(False)
# 设定图标的大小
self.navigation_bar.setIconSize(QSize(2, 2))
# 添加导航栏到窗口中
self.addToolBar(self.navigation_bar)
# 添加其它配置
self.navigation_bar.setObjectName("navigation_bar")
self.navigation_bar.setCursor(Qt.ArrowCursor)
# QAction类提供了抽象的用户界面action，这些action可以被放置在窗口部件中
# 添加前进、后退、停止加载和刷新的按钮
self.reload_icon = unichr(0xf2f9)
self.stop_icon = unichr(0xf00d)
# 后退按钮
self.back_action = QWidgetAction(self)
self.back_button = QPushButton(unichr(0xf060), self,
clicked=webview.back,
font=fontawesome("far"),
objectName='back_button')
self.back_button.setToolTip("后退")
self.back_button.setCursor(Qt.ArrowCursor)
self.back_action.setDefaultWidget(self.back_button)
# 前进按钮
self.next_action = QWidgetAction(self)
self.next_button = QPushButton(unichr(0xf061), self,
clicked=webview.forward,
font=fontawesome("far"),
objectName='next_button')
self.next_button.setToolTip("前进")
self.next_button.setCursor(Qt.ArrowCursor)
self.next_action.setDefaultWidget(self.next_button)
# 刷新与停止按钮
self.reload_action = QWidgetAction(self)
self.reload_button = QPushButton(self.reload_icon, self,
clicked=webview.reload,
font=fontawesome("far"),
objectName='reload_button')
self.reload_button.setToolTip("刷新")
self.reload_button.setCursor(Qt.ArrowCursor)
self.reload_action.setDefaultWidget(self.reload_button)
# 放大按钮
self.zoom_in_button = QPushButton(unichr(0xf067), self,
clicked=self.zoom_in_func,
font=fontawesome("far"),
objectName='zoom_in_btn')
self.zoom_in_button.setToolTip("放大")
self.zoom_in_button.setCursor(Qt.ArrowCursor)
# 缩小按钮
self.zoom_out_button = QPushButton(unichr(0xf068), self,
clicked=self.zoom_out_func,
font=fontawesome("far"),
objectName='zoom_out_btn')
self.zoom_out_button.setToolTip("缩小")
self.zoom_out_button.setCursor(Qt.ArrowCursor)
self.sf_label_rate = QLabel()
self.sf_label_rate.setObjectName("sf_label_rate")
self.sf_label_rate.setFixedWidth(30)
self.sf_label_rate.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
self.sf_label_rate.setProperty("class","qlabel")
self.sf_label_rate.setText(str(int(self.webview.zoomFactor()*100))+"%")
# 全屏按钮
self.full_screen_button = QPushButton(unichr(0xe140), self,
clicked=self.full_screen_func,
font=fontawesome("boot"),
objectName='full_screen_button')
self.full_screen_button.setToolTip("全屏")
self.full_screen_button.setCursor(Qt.ArrowCursor)
# 其它按钮
self.more_action = QWidgetAction(self)
self.more_button = QPushButton(unichr(0xe235), self,
clicked=self.moreMenuShow,
font=fontawesome("boot"),
objectName='more_button')
self.more_button.setToolTip("页面控制及浏览器核心")
self.more_button.setCursor(Qt.ArrowCursor)
self.more_action.setDefaultWidget(self.more_button)
# 首页按钮
self.index_action = QWidgetAction(self)
self.index_button = QPushButton(unichr(0xf015), self,
# clicked=self.zoom_out_func,
font=fontawesome("far"),
objectName='index_button')
self.index_button.setToolTip("主页")
self.index_button.setCursor(Qt.ArrowCursor)
self.index_action.setDefaultWidget(self.index_button)
# self.back_button.triggered.connect(webview.back)
# self.next_button.triggered.connect(webview.forward)
# self.reload_button.triggered.connect(webview.reload)
# self.zoom_in_btn.triggered.connect(self.zoom_in_func)
# self.zoom_out_btn.triggered.connect(self.zoom_out_func)
# 将按钮添加到导航栏上
self.navigation_bar.addAction(self.back_action)
self.navigation_bar.addAction(self.next_action)
self.navigation_bar.addAction(self.reload_action)
self.navigation_bar.addAction(self.index_action)
# 添加URL地址栏
self.urlbar = QLineEdit()
# 让地址栏能响应回车按键信号
self.urlbar.returnPressed.connect(self.navigate_to_url)
# self.navigation_bar.addSeparator()
self.navigation_bar.addWidget(self.urlbar)
# self.navigation_bar.addSeparator()
# self.navigation_bar.addAction(self.zoom_in_action)
# self.navigation_bar.addAction(self.zoom_out_action)
self.navigation_bar.addAction(self.more_action)
# 让浏览器相应url地址的变化
webview.urlChanged.connect(self.renew_urlbar)
webview.loadProgress.connect(self.processLoad)
webview.loadStarted.connect(self.loadPage)
webview.loadFinished.connect(self.loadFinish)
webview.titleChanged.connect(self.renew_title)
webview.iconChanged.connect(self.renew_icon)
self.webBind()
webview.show()
self.navigation_bar.setIconSize(QSize(20, 20))
self.urlbar.setFont(QFont('SansSerif', 13))
def zoom_in_func(self):
self.webview.setZoomFactor(self.webview.zoomFactor() + 0.1)
self.sf_label_rate.setText(str(int(self.webview.zoomFactor()*100))+"%")
def zoom_out_func(self):
self.webview.setZoomFactor(self.webview.zoomFactor() - 0.1)
self.sf_label_rate.setText(str(int(self.webview.zoomFactor()*100))+"%")
def full_screen_func(self):
self.navigation_bar.setHidden(True)
self.mainWin.titleBar.setHidden(True)
self.mainWin.showFullScreen()
def on_network_call(self, info):
print(info)
pass
def loadPage(self):
# print("loadPage")
# print(self.webview.objectName())
# self.renew_title("空页面")
index = self.mainWin.tabWidget.currentIndex()
self.mainWin.tabWidget.setTabIcon(index, QIcon(":icons/earth_128.png"))
# self.reload_button.setDefaultWidget(self.stop_button_icon)
self.reload_button.setText(self.stop_icon)
self.reload_button.setToolTip("停止")
def processLoad(self, rate):
self.mainWin.statusBarLabelProgress.setValue(rate)
self.mainWin.statusBarLabel.setText("网页加载")
if rate == 0:
self.mainWin.statusBarLabelProgress.setMaximum(0)
self.mainWin.statusBarLabelProgress.setMinimum(0)
else:
self.mainWin.statusBarLabelProgress.setMaximum(0)
self.mainWin.statusBarLabelProgress.setMinimum(100)
if rate == 100:
self.mainWin.statusBarLabelProgress.setHidden(True)
self.mainWin.statusBarLabel.setHidden(True)
self.mainWin.statusBar.setHidden(True)
else:
self.mainWin.statusBarLabelProgress.setHidden(False)
self.mainWin.statusBarLabel.setHidden(False)
self.mainWin.statusBar.setHidden(False)
pass
def loadFinish(self, isEnd):
if isEnd:
# print("load finished", isEnd)
# self.reload_button.setDefaultWidget(self.reload_button_icon)
self.reload_button.setText(self.reload_icon)
self.reload_button.setToolTip("刷新")
else:
# print("load finished", isEnd)
# print("load finished",isEnd)
pass
# index = self.webview.objectName()
# title = self.page.title()
# print("title", title)
try:
url = self.page.url().toString()
except BaseException as base:
url = self.webview.page().url().toString()
# self.mainWin.tabWidget.setTabText(int(index), title if title else url)
self.urlbar.setText(url)
def webBind(self):
# print("webBind")
# self.back_button.disconnect()
# self.next_button.disconnect()
# self.stop_button.disconnect()
# self.reload_button.disconnect()
# self.add_button.disconnect()
# self.back_button.triggered.connect(self.webview.back)
# self.next_button.triggered.connect(self.webview.forward)
# self.stop_button.triggered.connect(self.webview.stop)
# self.reload_button.triggered.connect(self.webview.reload)
# self.add_button.triggered.connect(self.mainWin.newTab)
self.webview.urlChanged.connect(self.renew_urlbar)
self.webview.titleChanged.connect(self.renew_title)
self.webview.iconChanged.connect(self.renew_icon)
def navigate_to_url(self):
q = QUrl(self.urlbar.text())
if q.scheme() == '':
q.setScheme('http')
self.webview.setUrl(q)
def renew_urlbar(self, url):
# 将当前网页的链接更新到地址栏
# print("renew_urlbar")
self.urlbar.setText(url.toString())
self.urlbar.setCursorPosition(0)
# print("url", url)f
def renew_title(self, title):
# 将当前网页的标题更新到标签栏
index = self.webview.objectName()
self.mainWin.tabWidget.setTabToolTip(int(index), title)
title = " " + title[:11] + ".." if len(title) >= 12 else " " + title
self.mainWin.tabWidget.setTabText(int(index), title)
pass
def renew_icon(self, icon):
# 将当前网页的图标更新到标签栏
# print("renew_icon")
index = self.webview.objectName()
self.mainWin.tabWidget.setTabIcon(int(index), icon)
def center(self):
# print("center")
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
# 创建tab
def create_tab(self, webview):
# print("create_tab")
self.tab = QWidget()
self.mainWin.tabWidget.addTab(self.tab, "新标签页")
self.mainWin.tabWidget.setCurrentWidget(self.tab)
index = self.mainWin.tabWidget.currentIndex()
# self.mainWin.tabWidget.setTabIcon(index, ":icons/logo.png")
#####
self.Layout = QVBoxLayout(self.tab)
self.Layout.setContentsMargins(0, 0, 0, 0)
self.Layout.addWidget(Browser(self.mainWin, webview=webview))
webview.setObjectName(str(index))
self.mainWin.tab_[str(index)] = webview
self.tab.setObjectName("tab_" + str(index))
def __init__(self, parent, tab):
QWebEnginePage.__init__(self, parent)
self.tab = tab
def __init__(self, debug=False):
QWebEnginePage.__init__(self)
def __init__(self, *args, **kwargs):
QWebEnginePage.__init__(self, *args, **kwargs)
self.featurePermissionRequested.connect(
self.onFeaturePermissionRequested)
def __init__(self, debug=False):
QWebEnginePage.__init__(self)
def __init__(self, parent, cp750bridge, args):
QWebEnginePage.__init__(self, parent)
self.args = args
channel = QWebChannel(self)
self.setWebChannel(channel)
channel.registerObject("cp750bridge", cp750bridge)
class Umbrella(QMainWindow, Ui_MainWindow):
#생성자
def __init__(self):
super().__init__()
self.init_my_location()
self.setupUi(self) # 초기화
self.url = "http://localhost:8080/umbrella"
# self.url = "http://localhost:8000/umbrella2.html"
self.webEngineView.load(QUrl(self.url))
self.page = QWebEnginePage()
self.page.setUrl(QUrl(self.url))
self.page.setView(self.webEngineView)
self.appLoaded = False
chrome_option = Options()
chrome_option.add_argument("--headless")
chrome_option.add_argument("--mute-audio")
self.browser = webdriver.Chrome(
chrome_options=chrome_option,
executable_path="resources/chromedriver.exe")
self.browser.get(self.url)
self.user_uuid = uuid.uuid4()
self.runner = Runner(self)
self.dc = DataCollector(self)
# self.comboBox.addItem("키워드")
# self.comboBox.addItem("주소")
self.itemList = []
self.rowList = []
#page 변환
self.pushButton_3.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(1))
self.pushButton__image.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(0))
self.pushButton.clicked.connect(self.runner.map_removeMarkers)
#intro 데이터 입력
self.lineEdit.returnPressed.connect(
lambda: self.runner.search(self.lineEdit.text().strip()))
self.pushButton.clicked.connect(
lambda: self.runner.search(self.lineEdit.text().strip()))
self.page.loadFinished.connect(lambda: self.runner.setMap(
self.my_location_lat, self.my_location_lng))
# self.setMap(self.my_location_lat, self.my_location_lng)
self.pushButton2.clicked.connect(self.mark_around)
self.pushButton3.clicked.connect(lambda: self.runner.setMap(
self.my_location_lat, self.my_location_lng))
self.page.urlChanged.connect(self.setButton)
self.listWidget.itemActivated.connect(self.activateRow)
# self.lineEdit.setText(self.runner.coord_to_address(self.my_location_lat,self.my_location_lng, 0))
self.lineEdit.setText(
self.runner.coord_to_address(self.my_location_lat,
self.my_location_lng, 0))
def mark_around(self):
self.remove_list()
if not self.page.url().toString().strip().startswith(
"http://localhost:8080/umbrella"):
self.page.load(QUrl(self.url))
return
self.runner.map_removeMarkers()
lat, lng = self.runner.map_getCenter()
data = self.dc.get_data_by_latlng(lat, lng, 1000)
self.runner.marking(data)
self.show_list(data)
self.lineEdit.setText(self.runner.coord_to_address(lat, lng, 0))
print("uuid---------------------------------", self.user_uuid)
# def checkBox_mark_around(self):
#표지
def intro(self):
#Text
self.dc.show_intro_list()
#그래프
self.dc.intro_graph()
def init_my_location(self):
url = 'https://www.googleapis.com/geolocation/v1/geolocate?key=AIzaSyDQKxbTt0MrFNH85kTJXzickMD5s88UVaI'
data = {
'considerIp': True,
}
result = requests.post(url, data)
my_location = json.loads(result.text)
# print(my_location)
# print("lat : ",my_location.get('location').get('lat'))
# print("lon : ",my_location.get('location').get('lng'))
self.my_location_lat = str(my_location.get('location').get('lat'))
self.my_location_lng = str(my_location.get('location').get('lng'))
def setButton(self):
if self.page.url().toString().strip().startswith(
"http://localhost:8080/umbrella"):
self.pushButton2.setText("판매처 탐색")
else:
self.pushButton2.setText("지도 새로고침")
def show_list(self, data):
for i in range(len(data)):
item = QListWidgetItem(self.listWidget)
row = Item(data[i])
item.setWhatsThis(str(i))
item.setSizeHint(row.sizeHint())
self.listWidget.setItemWidget(item, row)
self.listWidget.addItem(item)
self.itemList.append(item)
self.rowList.append(row)
def remove_list(self):
for i in range(len(self.itemList)):
self.itemList[i].setHidden(True)
self.itemList = []
self.rowList = []
def activateRow(self, row):
self.runner.setMap(self.rowList[int(row.whatsThis())].lat,
self.rowList[int(row.whatsThis())].lng)
self.runner.info_open(self.rowList[int(row.whatsThis())].code)
def acceptNavigationRequest(self, url, _type, isMainFrame):
#print("acceptNavigationRequest")
# print(url)
return QWebEnginePage.acceptNavigationRequest(self, url, _type,
isMainFrame)
def __init__(self, url):
self.app = QApplication(sys.argv)
QWebPage.__init__(self)
self.loadFinished.connect(self.on_page_load)
self.load(QUrl(url))
self.app.exec_()
class POSM(QMainWindow):
def __init__(self):
super().__init__()
self.setLocale(QLocale(QLocale.English))
self.initUI()
self.setAttribute(Qt.WA_AlwaysShowToolTips)
sizegrip = QtWidgets.QSizeGrip(self)
self.layout.addWidget(sizegrip, 0,
QtCore.Qt.AlignBottom | QtCore.Qt.AlignRight)
self.record = [None]
recordAction = QAction(datetime.datetime.now().strftime('%H:%M:%S'),
self)
recordAction.triggered.connect(lambda: self.changeMap(0))
self.recordMenu.addAction(recordAction)
def initUI(self):
self.layout = QHBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.console = InformationalConsole(app)
self.horSplitter = QSplitter(Qt.Horizontal)
self.horSplitter.setChildrenCollapsible(False)
self.editionSplitter = QSplitter(Qt.Vertical)
self.editionSplitter.setChildrenCollapsible(False)
self.queryUI = QueryUI()
self.queryUI.setOnRequestChanged(self.changeCurrentMap)
self.editionSplitter.addWidget(self.queryUI)
self.queryWidget = QWidget()
self.queryWidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Maximum)
self.queryWidget.setLayout(QVBoxLayout())
self.queryWidget.layout().setContentsMargins(0, 0, 0, 0)
self.queryWidget.layout().setSpacing(0)
self.queryHeader = QLabel("Query")
self.queryHeader.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.queryHeader.setFixedHeight(self.queryHeader.sizeHint().height() +
10)
self.queryHeader.setContentsMargins(5, 5, 0, 5)
self.queryWidget.layout().addWidget(self.queryHeader)
self.queryText = CodeEditor()
self.qlHighlighter = OverpassQLHighlighter(self.queryText.document())
self.queryText.setReadOnly(True)
self.queryWidget.layout().addWidget(self.queryText)
self.editionSplitter.addWidget(self.queryWidget)
self.horSplitter.addWidget(self.editionSplitter)
self.emptyMapPage = QWebEnginePage()
self.emptyMapPage.setHtml(EMPTY_HTML)
self.manualModePage = QWebEnginePage()
soup = bs4.BeautifulSoup(EMPTY_HTML, features="html.parser")
js = soup.new_tag("script")
js.string = (MANUAL_MODE_JS_SCRIPT % (str([])))
soup.append(js)
self.manualModePage.setHtml(str(soup))
self.mapRenderer = QWebEngineView()
self.mapRenderer.setMinimumWidth(500)
self.mapRenderer.setPage(self.emptyMapPage)
self.consoleSplitter = QSplitter(Qt.Vertical)
self.consoleSplitter.setChildrenCollapsible(False)
self.consoleSplitter.addWidget(self.mapRenderer)
self.consoleWidget = QWidget()
self.consoleWidget.setLayout(QVBoxLayout())
self.consoleWidget.layout().setContentsMargins(0, 0, 0, 0)
self.consoleWidget.layout().setSpacing(0)
self.consoleHeader = QLabel("Console")
self.consoleHeader.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.consoleHeader.setContentsMargins(5, 5, 0, 5)
self.consoleWidget.layout().addWidget(self.consoleHeader)
self.consoleWidget.layout().addWidget(self.console)
self.consoleSplitter.addWidget(self.consoleWidget)
self.horSplitter.addWidget(self.consoleSplitter)
self.layout.addWidget(self.horSplitter)
self.initMenuBar()
centralWidget = QWidget(self)
centralWidget.setLayout(self.layout)
self.setCentralWidget(centralWidget)
self.setWindowTitle('Python Open Street Map')
def initMenuBar(self):
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
openAct = QAction('Open netedit', self)
openAct.triggered.connect(self.openNet)
fileMenu.addAction(openAct)
saveMenu = fileMenu.addMenu("Save")
saveOutputAct = QAction('output', self)
saveOutputAct.triggered.connect(self.saveNet)
saveOutputAct.setShortcut('Ctrl+S')
saveMenu.addAction(saveOutputAct)
saveQueryAct = QAction('query', self)
saveQueryAct.triggered.connect(self.saveQuery)
saveQueryAct.setShortcut('Ctrl+Shift+S')
saveMenu.addAction(saveQueryAct)
saveInteractiveModeAct = QAction('interactive mode', self)
saveInteractiveModeAct.triggered.connect(self.saveInteractiveQuery)
saveMenu.addAction(saveInteractiveModeAct)
openMenu = fileMenu.addMenu("Open")
openQuery = QAction('query', self)
openQuery.triggered.connect(self.openQuery)
openQuery.setShortcut('Ctrl+O')
openMenu.addAction(openQuery)
openInteractiveMode = QAction('interactive mode', self)
openInteractiveMode.triggered.connect(self.openInteractiveQuery)
openMenu.addAction(openInteractiveMode)
self.recordMenu = openMenu.addMenu("record")
runMenu = menubar.addMenu('Run')
playAct = QAction('Play', self)
playAct.triggered.connect(self.playQuery)
playAct.setShortcut('Ctrl+P')
runMenu.addAction(playAct)
playTableRowAct = QAction('Play row selection', self)
playTableRowAct.triggered.connect(self.playTableRow)
playTableRowAct.setShortcut('Ctrl+T')
runMenu.addAction(playTableRowAct)
self.requestMenu = menubar.addMenu('Request')
addRequestAct = QAction('Add request', self)
addRequestAct.triggered.connect(lambda b: self.addRequest())
addRequestAct.setShortcut('Ctrl+A')
self.requestMenu.addAction(addRequestAct)
templatesMenu = self.requestMenu.addMenu("Add template")
addRoadAct = QAction('Roads', self)
addRoadAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("highway", TagComparison.EQUAL, "", False, True),
OverpassFilter("name", TagComparison.EQUAL, "", False, True),
OverpassFilter("ref", TagComparison.EQUAL, "", False, True),
OverpassFilter("maxspeed", TagComparison.AT_MOST, "120", False,
False),
OverpassFilter("lanes", TagComparison.EQUAL, "", False, True),
OverpassFilter("oneway", TagComparison.EQUAL, "", False, True)
]))
templatesMenu.addAction(addRoadAct)
addMainRoadAct = QAction('Main roads', self)
mainHighways = "^(motorway|trunk|primary|secondary|residential)(_link)?$"
everythingButYes = "^(y(e([^s]|$|s.)|[^e]|$)|[^y]|$).*"
addMainRoadAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("highway", TagComparison.EQUAL, mainHighways, False,
False),
OverpassFilter("construction", TagComparison.HAS_NOT_KEY, "",
False, False),
OverpassFilter("noexit", TagComparison.EQUAL, "yes", True, True),
OverpassFilter("access", TagComparison.EQUAL, everythingButYes,
True, False)
]))
templatesMenu.addAction(addMainRoadAct)
addParkingAct = QAction('Parking', self)
addParkingAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("service", TagComparison.EQUAL, "parking", False,
False),
OverpassFilter("highway", TagComparison.HAS_KEY, "", False, True)
]))
templatesMenu.addAction(addParkingAct)
addPedestriansAct = QAction('Pedestrians', self)
pedestrianHighway = [
"pedestrian", "footway", "path", "cycleway", "bridleway", "steps",
"crossing"
]
addPedestriansAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("highway", TagComparison.IS_ONE_OF,
pedestrianHighway, False, True)
]))
templatesMenu.addAction(addPedestriansAct)
removeRequestAct = QAction('Remove current request', self)
removeRequestAct.triggered.connect(self.removeRequest)
removeRequestAct.setShortcut('Ctrl+R')
self.requestMenu.addAction(removeRequestAct)
self.manualModeAct = QAction(
'Switch between interactive and manual mode', self)
self.manualModeAct.triggered.connect(self.switchManualMode)
self.requestMenu.addAction(self.manualModeAct)
self.manualModeMenu = menubar.addMenu('Manual mode')
self.manualModeMenu.setEnabled(False)
manualModeCleanPolygonAct = QAction('Clean polygon', self)
manualModeCleanPolygonAct.triggered.connect(
self.cleanManualModePolygon)
self.manualModeMenu.addAction(manualModeCleanPolygonAct)
manualModeGetPolygonAct = QAction('Polygon coordinates', self)
manualModeGetPolygonAct.triggered.connect(
lambda: self.manualModePage.runJavaScript(
"getPolygons();", self.logManualModePolygonCoords))
self.manualModeMenu.addAction(manualModeGetPolygonAct)
windowsMenu = menubar.addMenu('Windows')
cleanMapAct = QAction('Clean map', self)
cleanMapAct.triggered.connect(self.cleanMap)
windowsMenu.addAction(cleanMapAct)
self.showHideInteractiveModeAct = QAction('Interactive mode', self)
self.showHideInteractiveModeAct.triggered.connect(
self.showHideInteractiveMode)
windowsMenu.addAction(self.showHideInteractiveModeAct)
showHideConsole = QAction('Console', self)
showHideConsole.triggered.connect(self.showHideConsole)
windowsMenu.addAction(showHideConsole)
showHideQuery = QAction('Query', self)
showHideQuery.triggered.connect(self.showHideQuery)
windowsMenu.addAction(showHideQuery)
# ACTIONS
def cleanMap(self):
if self.queryText.isReadOnly():
if self.queryUI.getCurrentMap() is not None:
self.mapRenderer.setPage(self.queryUI.updateMaps(EMPTY_HTML))
else:
soup = bs4.BeautifulSoup(EMPTY_HTML, features="html.parser")
js = soup.new_tag("script")
js.string = (MANUAL_MODE_JS_SCRIPT % (str([])))
soup.append(js)
self.manualModePage.setHtml(str(soup))
logging.info("Cleaning map")
def changeMap(self, i):
if i == 0:
if not self.queryText.isReadOnly():
self.switchManualMode()
if self.queryText.isReadOnly():
self.queryUI.reset()
self.queryText.clear()
self.mapRenderer.setPage(self.emptyMapPage)
self.queryUI.updateMaps(EMPTY_HTML)
elif self.record[i]["interactiveMode"]:
if not self.queryText.isReadOnly():
self.switchManualMode()
if self.queryText.isReadOnly():
self.queryUI.setQuery(self.record[i]["query"])
self.queryText.setPlainText(self.record[i]["query"].getQL())
self.mapRenderer.setPage(
self.queryUI.updateMaps(self.record[i]["html"]))
else:
if self.queryText.isReadOnly():
self.switchManualMode()
if not self.queryText.isReadOnly():
self.queryUI.reset()
self.queryText.setPlainText(self.record[i]["query"])
self.manualModePage.setHtml(self.record[i]["html"])
self.mapRenderer.setPage(self.manualModePage)
def logManualModePolygonCoords(self, coords):
coordsString = " ".join([str(c) for point in coords for c in point])
logging.info("Polygon coordinates:\"{}\"".format(coordsString))
pyperclip.copy(coordsString)
logging.debug("LINE")
def cleanManualModePolygon(self):
logging.info("Cleaning polygon.")
self.manualModePage.runJavaScript(
"cleanPolygon();", lambda returnValue: logging.debug("LINE"))
def showHideInteractiveMode(self):
if self.queryUI.isHidden():
if self.editionSplitter.isHidden():
self.editionSplitter.show()
self.queryText.hide()
self.queryUI.show()
logging.info("Showing 'Interactive mode' window.")
else:
if self.queryText.isHidden():
self.editionSplitter.hide()
self.queryUI.hide()
logging.info("Hiding 'Interactive mode' window.")
logging.debug("LINE")
def showHideConsole(self):
if self.console.isHidden():
self.console.show()
logging.info("Showing 'Console' window.")
self.consoleWidget.setMaximumHeight(QWIDGETSIZE_MAX)
else:
self.console.hide()
self.consoleWidget.setMaximumHeight(
self.queryHeader.sizeHint().height())
logging.info("Hiding 'Console' window.")
logging.debug("LINE")
def showHideQuery(self):
if self.queryText.isHidden():
if self.editionSplitter.isHidden():
self.editionSplitter.show()
self.queryUI.hide()
self.queryText.show()
logging.info("Showing 'Query' window.")
self.queryWidget.setMaximumHeight(QWIDGETSIZE_MAX)
else:
if self.queryUI.isHidden():
self.editionSplitter.hide()
self.queryText.hide()
self.queryWidget.setMaximumHeight(
self.queryHeader.sizeHint().height())
logging.info("Hiding 'Query' window.")
logging.debug("LINE")
def switchManualMode(self):
if self.queryText.isReadOnly():
reply = QMessageBox.question(
self, "Manual mode",
"Are you sure?\nThe interactive mode will remain as it is now."
)
if reply == QMessageBox.Yes:
self.queryText.setReadOnly(False)
self.queryUI.hide()
for action in self.requestMenu.actions():
action.setEnabled(False)
self.manualModeAct.setEnabled(True)
self.manualModeMenu.setEnabled(True)
self.showHideInteractiveModeAct.setEnabled(False)
self.mapRenderer.setPage(self.manualModePage)
logging.info("Switching to manual mode.")
else:
logging.info(
"'Switch between interactive and manual mode' cancelled.")
else:
reply = QMessageBox.question(
self, "Interactive mode",
"Are you sure?\nThe current query will be removed.")
if reply == QMessageBox.Yes:
try:
self.queryText.clear()
self.queryText.setPlainText(
self.queryUI.getQuery().getQL())
except BadFilterAttributes as e:
logging.error(str(e))
except RuntimeError:
logging.warning("Failed to write query.")
self.queryText.clear()
self.queryText.setPlainText("")
self.queryText.setReadOnly(True)
self.queryUI.show()
for action in self.requestMenu.actions():
action.setEnabled(True)
self.manualModeMenu.setEnabled(False)
self.showHideInteractiveModeAct.setEnabled(True)
self.changeCurrentMap(0)
logging.info("Switching to interactive mode.")
else:
logging.info(
"'Switch between interactive and manual mode' cancelled.")
logging.info("Showing 'manual mode' polygon.")
def addRequest(self, filters=None):
self.queryUI.addRequestByFilters(filters)
logging.info("Request added.")
logging.debug("LINE")
def addTemplate(self, filters):
logging.info("Template applied.")
self.queryUI.addRequestByFilters(filters)
def removeRequest(self):
reply = QMessageBox.question(
self, "Remove current request",
"Are you sure? This option is not undoable.")
if reply == QMessageBox.Yes:
self.queryUI.removeRequest()
logging.info("'Remove request' successfully executed.")
else:
logging.info("'Remove request' cancelled.")
logging.debug("LINE")
def saveQuery(self):
filename, selectedFilter = QFileDialog.getSaveFileName(
self, 'Save query', expanduser("~/filename.txt"),
"Text files (*.txt)")
if filename != "":
if self.queryText.isReadOnly():
try:
query = self.queryUI.getQuery().getQL()
f = open(filename, "w+")
f.seek(0)
f.truncate()
f.write(query)
f.close()
logging.info("Query saved successfully.")
except (RuntimeError, BadFilterAttributes) as e:
logging.error(str(e))
except OSError:
logging.error(
"There was a problem creating the file with the query."
)
else:
try:
f = open(filename, "w+")
f.seek(0)
f.truncate()
f.write(self.queryText.toPlainText())
f.close()
logging.info("Query saved successfully.")
except OSError:
logging.error(
"There was a problem creating the file with the query."
)
else:
logging.info("\"Save query\" canceled.")
logging.debug("LINE")
def openQuery(self):
filename, selectedFilter = QFileDialog.getOpenFileName(
self, 'Open query', expanduser("~/filename.txt"))
if filename != "":
try:
if self.queryText.isReadOnly():
self.switchManualMode()
f = open(filename, "r")
self.queryText.clear()
self.queryText.setPlainText(f.read())
f.close()
logging.info("File read successfully.")
except UnicodeDecodeError:
logging.error("The given file is not readable as text.")
except OSError:
logging.error("There was a problem opening the query file.")
else:
logging.info("\"Open query\" canceled.")
logging.debug("LINE")
def saveInteractiveQuery(self):
filename, selectedFilter = QFileDialog.getSaveFileName(
self, 'Save query', expanduser("~/filename.json"),
"JSON files (*.json)")
if filename != "":
try:
query = self.queryUI.getQuery()
query.saveToFile(filename)
logging.info("Query saved successfully.")
except (RuntimeError, BadFilterAttributes) as e:
logging.error(str(e))
except OSError:
logging.error(
"There was a problem creating the file with the query.")
else:
logging.info("\"Save query\" canceled.")
logging.debug("LINE")
def openInteractiveQuery(self):
filename, selectedFilter = QFileDialog.getOpenFileName(
self, 'Open query', expanduser("~/filename.json"))
if filename != "":
try:
self.queryUI.setQuery(OverpassQuery.getFromFile(filename))
if not self.queryText.isReadOnly():
self.switchManualMode()
except json.decoder.JSONDecodeError:
logging.error(
"The given file has not the right format (json). The file could not be opened."
)
except UnicodeDecodeError:
logging.error(
"The given file is not readable as text. The file could not be opened."
)
except (TypeError, KeyError):
logging.error(
"Fields are missing from the file or there are fields with the wrong data type. "
"The file could not be opened.")
except OSError:
logging.error(
"There was a problem opening the query file. The file could not be opened."
)
else:
logging.info("\"Open query\" canceled.")
logging.debug("LINE")
def saveNet(self):
filename, selectedFilter = QFileDialog.getSaveFileName(
self, 'Save File', expanduser("~/filenameWithoutExtension"))
if filename != "":
buildNet(filename)
else:
logging.info("\"Save File\" canceled.")
logging.debug("LINE")
return filename
def openNet(self):
try:
filename = self.saveNet()
if filename == "":
logging.error("Can't open NETEDIT without a file.")
else:
openNetedit(filename + ".net.xml")
logging.info("Opening NETEDIT.")
logging.warning(
"If NETEDIT is not open in ten seconds, there was an unhandled problem."
)
logging.debug("LINE")
except OSError:
logging.error("Can't find NETEDIT.")
except Exception:
logging.error(traceback.format_exc())
# POLYGONS
def changeCurrentMap(self, i):
if self.queryUI.getCurrentMap() is None:
self.mapRenderer.setPage(self.emptyMapPage)
else:
self.mapRenderer.setPage(self.queryUI.getCurrentMap())
def playQuery(self):
newRecord = {
"interactiveMode": self.queryText.isReadOnly(),
"query": self.queryText.toPlainText(),
"html": ""
}
if self.queryText.isReadOnly():
try:
query = self.queryUI.getQuery()
newRecord["query"] = query
self.queryText.setPlainText(query.getQL())
except (RuntimeError, BadFilterAttributes) as e:
logging.error(str(e))
return
try:
html = buildHTMLWithQuery(self.queryText.toPlainText())
if self.queryText.isReadOnly():
self.mapRenderer.setPage(self.queryUI.updateMaps(html))
newRecord["html"] = html
else:
soup = bs4.BeautifulSoup(html, features="html.parser")
js = soup.new_tag("script")
js.string = (MANUAL_MODE_JS_SCRIPT % (str([])))
soup.append(js)
self.manualModePage.setHtml(str(soup))
newRecord["html"] = str(soup)
self.mapRenderer.setPage(self.manualModePage)
logging.info("Query drawn.")
logging.debug("LINE")
self.addRecord(newRecord)
except (OverpassRequestException, OsmnxException) as e:
logging.error(str(e))
except ox.EmptyOverpassResponse:
logging.error("There are no elements with the given query.")
except OSError:
logging.error(
"There was a problem creating the file with the request response."
)
except Exception:
logging.error(traceback.format_exc())
def addRecord(self, newRecord):
self.record.append(newRecord)
index = len(self.record) - 1
recordAction = QAction(datetime.datetime.now().strftime('%H:%M:%S'),
self)
recordAction.triggered.connect(lambda: self.changeMap(index))
self.recordMenu.addAction(recordAction)
def playTableRow(self):
try:
self.mapRenderer.setPage(self.queryUI.updateMapFromRow())
except (OverpassRequestException, OsmnxException) as e:
logging.error(str(e))
logging.warning(
"Before open NETEDIT you must run a query with the row filters applied."
)
except ox.EmptyOverpassResponse:
logging.error("There are no elements with the given row.")
except OSError:
logging.error(
"There was a problem creating the file with the row selection."
)
except RuntimeError as e:
logging.error(str(e))
except Exception:
logging.error(traceback.format_exc())
logging.debug("LINE")
# EVENTS
def closeEvent(self, event):
for f in os.listdir(tempDir):
os.remove(os.path.join(tempDir, f))
QMainWindow.closeEvent(self, event)
def __init__(self):
self._is_loaded = False
self._motion_graph = None
QWebEnginePage.__init__(self)
def initUI(self):
self.layout = QHBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.console = InformationalConsole(app)
self.horSplitter = QSplitter(Qt.Horizontal)
self.horSplitter.setChildrenCollapsible(False)
self.editionSplitter = QSplitter(Qt.Vertical)
self.editionSplitter.setChildrenCollapsible(False)
self.queryUI = QueryUI()
self.queryUI.setOnRequestChanged(self.changeCurrentMap)
self.editionSplitter.addWidget(self.queryUI)
self.queryWidget = QWidget()
self.queryWidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Maximum)
self.queryWidget.setLayout(QVBoxLayout())
self.queryWidget.layout().setContentsMargins(0, 0, 0, 0)
self.queryWidget.layout().setSpacing(0)
self.queryHeader = QLabel("Query")
self.queryHeader.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.queryHeader.setFixedHeight(self.queryHeader.sizeHint().height() +
10)
self.queryHeader.setContentsMargins(5, 5, 0, 5)
self.queryWidget.layout().addWidget(self.queryHeader)
self.queryText = CodeEditor()
self.qlHighlighter = OverpassQLHighlighter(self.queryText.document())
self.queryText.setReadOnly(True)
self.queryWidget.layout().addWidget(self.queryText)
self.editionSplitter.addWidget(self.queryWidget)
self.horSplitter.addWidget(self.editionSplitter)
self.emptyMapPage = QWebEnginePage()
self.emptyMapPage.setHtml(EMPTY_HTML)
self.manualModePage = QWebEnginePage()
soup = bs4.BeautifulSoup(EMPTY_HTML, features="html.parser")
js = soup.new_tag("script")
js.string = (MANUAL_MODE_JS_SCRIPT % (str([])))
soup.append(js)
self.manualModePage.setHtml(str(soup))
self.mapRenderer = QWebEngineView()
self.mapRenderer.setMinimumWidth(500)
self.mapRenderer.setPage(self.emptyMapPage)
self.consoleSplitter = QSplitter(Qt.Vertical)
self.consoleSplitter.setChildrenCollapsible(False)
self.consoleSplitter.addWidget(self.mapRenderer)
self.consoleWidget = QWidget()
self.consoleWidget.setLayout(QVBoxLayout())
self.consoleWidget.layout().setContentsMargins(0, 0, 0, 0)
self.consoleWidget.layout().setSpacing(0)
self.consoleHeader = QLabel("Console")
self.consoleHeader.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.consoleHeader.setContentsMargins(5, 5, 0, 5)
self.consoleWidget.layout().addWidget(self.consoleHeader)
self.consoleWidget.layout().addWidget(self.console)
self.consoleSplitter.addWidget(self.consoleWidget)
self.horSplitter.addWidget(self.consoleSplitter)
self.layout.addWidget(self.horSplitter)
self.initMenuBar()
centralWidget = QWidget(self)
centralWidget.setLayout(self.layout)
self.setCentralWidget(centralWidget)
self.setWindowTitle('Python Open Street Map')
def __init__(self):
QWebEnginePage.__init__(self)
class Umbrella(QMainWindow, Ui_MainWindow):
def __init__(self):
super().__init__()
self.init_my_location()
self.setupUi(self) # 초기화
# self.url = "http://192.168.0.3:8080/umbrella"
self.url = "https://sambank.net/umbrella.html"
self.webEngineView.load(QUrl(self.url))
self.page = QWebEnginePage()
self.page.setUrl(QUrl(self.url))
self.page.setView(self.webEngineView)
# self.webEngineView2.load(QUrl("http://ncov.mohw.go.kr/bdBoardList_Real.do?brdId=1&brdGubun=11&ncvContSeq=&contSeq=&board_id=&gubun="))
self.appLoaded = False
chrome_option = Options()
chrome_option.add_argument("--headless")
chrome_option.add_argument("--mute-audio")
self.browser = webdriver.Chrome(
chrome_options=chrome_option,
executable_path="resources/chromedriver.exe")
self.browser.get(self.url)
self.user_uuid = uuid.uuid4()
self.runner = Runner(self)
self.dc = DataCollector(self)
self.dm = DataManager(self)
self.itemList = []
self.rowList = []
self.dataChecker = 0
# self.webEngineView2.load(QUrl(self.dc.html_test()))
self.initSignal()
self.timeSeries = self.dc.get_timeseries()
self.comboBox.addItem("-----")
for i in sorted(self.timeSeries.keys()):
self.comboBox.addItem(i)
#테트리스
# self.tboard = Board(self.page_3)
# self.tboard.msg2Statusbar.connect(self.test_1)
# self.tboard.start()
# self.tboard.setStyleSheet("background-color:#ffffff")
# self.tboard.setGeometry(460,0,460,820)
def test_1(self, msg):
if msg == "Game over":
self.tboard.initBoard()
self.tboard.start()
def initSignal(self):
#page 변환
self.pushButton_3.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(1))
self.pushButton_4.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(1))
self.intro_button.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(1))
self.pushButton_5.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(1))
self.pushButton__image.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(0))
self.pushButton__image2.clicked.connect(
lambda: self.stackedWidget.setCurrentIndex(0))
self.pushButton.clicked.connect(self.runner.map_removeMarkers)
#intro 데이터 입력
self.lineEdit.returnPressed.connect(
lambda: self.runner.search(self.lineEdit.text().strip()))
self.pushButton.clicked.connect(
lambda: self.runner.search(self.lineEdit.text().strip()))
self.page.loadFinished.connect(lambda: self.runner.setMap(
self.my_location_lat, self.my_location_lng))
self.pushButton2.clicked.connect(self.mark_around)
self.pushButton3.clicked.connect(lambda: self.runner.setMap(
self.my_location_lat, self.my_location_lng))
self.page.urlChanged.connect(self.setButton)
self.listWidget.itemActivated.connect(self.activateRow)
self.listWidget.itemClicked.connect(self.rowClicked)
self.lineEdit.setText(
self.runner.coord_to_address(self.my_location_lat,
self.my_location_lng, 0))
self.radio1.clicked.connect(lambda: self.setDataChecker(0))
self.radio2.clicked.connect(lambda: self.setDataChecker(2))
self.radio3.clicked.connect(lambda: self.setDataChecker(3))
self.radio4.clicked.connect(lambda: self.setDataChecker(4))
self.widget_1.pressed.connect(self.view_graph)
self.widget_2.pressed.connect(self.view_graph)
self.widget_3.pressed.connect(self.view_graph)
self.widget_4.pressed.connect(self.view_graph)
self.comboBox.currentTextChanged.connect(self.show_timeSeries)
def show_timeSeries(self, nat):
if nat in self.timeSeries.keys():
self.dm.graph_timeseries(self.timeSeries.get(nat))
def view_graph(self):
self.stackedWidget.setCurrentIndex(2)
def mark_around(self):
print("markaround")
self.remove_list()
if not self.page.url().toString().strip().startswith(self.url):
self.page.load(QUrl(self.url))
return
self.runner.map_removeMarkers()
try:
lat, lng = self.runner.map_getCenter()
except:
print("mark_arount exception")
return
data = self.dc.get_data_by_latlng(lat, lng, 1000)
self.runner.marking(data)
self.show_list(data)
self.lineEdit.setText(self.runner.coord_to_address(lat, lng, 0))
def setDataChecker(self, num):
self.dataChecker = num
#표지
def intro(self):
data = self.dc.A()
#Text
self.dm.show_intro_list(data)
#그래프
self.dm.intro_graph(data)
def init_my_location(self):
url = 'https://www.googleapis.com/geolocation/v1/geolocate?key=AIzaSyDQKxbTt0MrFNH85kTJXzickMD5s88UVaI'
data = {
'considerIp': True,
}
result = requests.post(url, data)
my_location = json.loads(result.text)
self.my_location_lat = str(my_location.get('location').get('lat'))
self.my_location_lng = str(my_location.get('location').get('lng'))
def setButton(self):
if self.page.url().toString().strip().startswith(
"https://sambank.net/umbrella"):
self.pushButton2.setText("판매처 탐색")
else:
self.pushButton2.setText("지도 새로고침")
def show_list(self, data):
remainP = [
'100개 이상', '30개 이상 100개 미만', '2개 이상 30개 미만', '1개 이하', '판매중지'
]
for i in range(len(data)):
item = QListWidgetItem(self.listWidget)
row = Item(data[i])
rs = data[i].get('remain_stat')
if rs == None:
row.remain_stat.setStyleSheet('color:red')
elif remainP.index(rs) <= 1:
row.remain_stat.setStyleSheet('color:green')
elif remainP.index(rs) == 2:
row.remain_stat.setStyleSheet('color:orange')
else:
row.remain_stat.setStyleSheet('color:red')
item.setWhatsThis(str(i))
item.setSizeHint(row.sizeHint())
self.listWidget.setItemWidget(item, row)
self.listWidget.addItem(item)
self.itemList.append(item)
self.rowList.append(row)
def remove_list(self):
for i in range(len(self.itemList)):
self.itemList[i].setHidden(True)
self.itemList = []
self.rowList = []
def activateRow(self, row):
self.runner.setMap(self.rowList[int(row.whatsThis())].lat,
self.rowList[int(row.whatsThis())].lng)
self.runner.info_open(self.rowList[int(row.whatsThis())].code)
def rowClicked(self, row):
self.runner.info_close_all()
self.runner.info_open(self.rowList[int(row.whatsThis())].code)
def __init__(self, parent=None):
super().__init__(parent)
self._flags = QWebEnginePage.FindFlags(0)
from PyQt5.QtCore import QT_VERSION_STR, QUrl, QDir, QObject, pyqtSlot, QJsonValue
from PyQt5.Qt import PYQT_VERSION_STR
from sip import SIP_VERSION_STR
from PyQt5.QtWebChannel import QWebChannel
print("Qt version:", QT_VERSION_STR) # Qt version: 5.11.2
print("SIP version:", SIP_VERSION_STR) # SIP version: 4.19.13
print("PyQt version:", PYQT_VERSION_STR) # PyQt version: 5.11.3
from PyQt5.QtWebEngineWidgets import QWebEnginePage, QWebEngineView
from PyQt5.QtWidgets import QApplication
app = QApplication([])
Page = QWebEnginePage()
view = QWebEngineView()
Page.setView(view)
class jscall(QObject):
def __init__(self):
super().__init__()
self.result = 'default'
@pyqtSlot(str)
def callme(self, arg: str):
# b = a.toObject()
print(arg)
def internal_view(self):
return QWebEnginePage.view(self)
def __init__(self, parent):
QWebEnginePage.__init__(self, create_profile(), parent)
secure_webengine(self, for_viewer=True)
self.bridge = PreviewBridge(self)
def url(self):
if self.__delay_loading_url:
return self.__delay_loading_url.url
return QWebEnginePage.url(self)
def find(self, direction):
text = unicode_type(self.search.text())
self.view._page.findText(
text, (QWebEnginePage.FindFlag.FindBackward
if direction == 'prev' else QWebEnginePage.FindFlags(0)))
def find(self, forwards=True):
text = unicode_type(self.search_text.text()).strip()
flags = QWebEnginePage.FindFlags(
0) if forwards else QWebEnginePage.FindBackward
self.find_data = text, flags, forwards
self.view.findText(text, flags, self.find_callback)
def __init__(self, parent, tab):
QWebEnginePage.__init__(self, parent)
self.tab = tab
