def loadPage(url):
page = QWebEnginePage()
loop = QEventLoop() # Create event loop
page.loadFinished.connect(loop.quit) # Connect loadFinished to loop quit
page.load(QUrl(url))
loop.exec_() # Run event loop, it will end on loadFinished
return page.toHtml(get_html)
async def load_p_url_then_run_js_co(page: QtWebEngineWidgets.QWebEnginePage,
u: Qt.QUrl, js: str, wcobjects: dict):
fut = asyncio.get_event_loop().create_future()
def register_channel_objects():
wc = QWebChannel(page)
wc.registerObjects(wcobjects)
page.setWebChannel(wc)
def ready(ok: bool):
su = page.url()
if su == u:
page.loadFinished.disconnect()
def jsready():
asyncio.get_event_loop().call_soon_threadsafe(
fut.set_result, ok)
try:
page.runJavaScript(js, jsready)
except Exception as je:
print(repr(je), file=sys.stderr)
traceback.print_stack()
# else we have about:blank or something like it, let it run more times
page.loadFinished.connect(ready)
register_channel_objects()
page.load(u)
return await fut
class Html2PdfConverter(QObject):
def __init__(self, inputPath: str, outputPath: str) -> None:
super().__init__()
self.m_inputPath = inputPath
self.m_outputPath = outputPath
self.m_page = QWebEnginePage()
self.m_page.loadFinished.connect(self.loadFinished)
self.m_page.pdfPrintingFinished.connect(self.pdfPrintingFinished)
def run(self) -> bool:
self.m_page.load(QUrl.fromUserInput(self.m_inputPath))
return QApplication.exec_()
@pyqtSlot(bool)
def loadFinished(self, ok: bool):
if not ok:
sys.stderr.write("failed to load URL '%s'" % (self.m_inputPath,))
QCoreApplication.exit(1)
return
self.m_page.printToPdf(self.m_outputPath)
@pyqtSlot(str, bool)
def pdfPrintingFinished(self, filePath: str, success: bool):
if not success:
sys.stderr.write("failed to print to output file '%s'" % (filePath,))
QCoreApplication.exit(1)
else:
QCoreApplication.quit()
class MapWidget(QWebEngineView):
"""
The MapWidget class is a QWebEngineView that houses the leaflet map.
Since it is a QWidget, it can be added to any QLayout.
"""
@property
def page(self):
return self._page
@property
def channel(self):
return self._channel
def __init__(self):
super().__init__()
self._page = QWebEnginePage()
self.setPage(self._page)
self._channel = QWebChannel()
self._page.setWebChannel(self._channel)
self._loadPage()
def _loadPage(self):
html_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'web', 'map.html')
# QEventLoop is used to make the page loading behave syncronously
init_loop = QEventLoop()
self._page.loadFinished.connect(init_loop.quit)
self._page.load(QUrl().fromLocalFile(html_path))
init_loop.exec()
class ExtractorHtml:
def __init__(self, url):
self.html = None
_app = QApplication([])
self._page = QWebEnginePage()
self._page.load(QUrl(url))
self._page.loadFinished.connect(self._load_finished_handler)
# Ожидание загрузки страницы и получения его содержимого
# Этот цикл асинхронный код делает синхронным
while self.html is None:
_app.processEvents()
_app.quit()
self._page = None
def _callable(self, data):
if check_content_func:
if check_content_func(data):
self.html = data
else:
self.html = data
def _load_finished_handler(self):
self._page.toHtml(self._callable)
class ExtractorHtml:
def __init__(self, url):
_app = QApplication([])
self._page = QWebEnginePage()
self._page.loadFinished.connect(self._load_finished_handler)
self.html = None
# Небольшой костыль для получения содержимого страницы сайта http://gama-gama.ru
# Загрузка страницы проходит 2 раза: сначада кусок хитрого javascript кода, потом страница
# сайта с содержимым
self._counter_finished = 0
self._page.load(QUrl(url))
# Ожидание загрузки страницы и получения его содержимого
# Этот цикл асинхронный код делает синхронным
while self.html is None:
_app.processEvents()
_app.quit()
# Чтобы избежать падений скрипта
self._page = None
def _callable(self, data):
self.html = data
def _load_finished_handler(self, _):
self._counter_finished += 1
if self._counter_finished == 2:
self._page.toHtml(self._callable)
class MainWindow(QMainWindow):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setWindowTitle("pyatter")
self.show()
self.browser = self.init_browser()
self.profile = self.init_profile(self.browser)
self.webpage = QWebEnginePage(self.profile, self.browser)
self.browser.setPage(self.webpage)
self.setCentralWidget(self.browser)
self.init_navbar()
url = "https://www.google.com"
self.webpage.load(QUrl(url))
def init_browser(self):
browser = QWebEngineView()
browser.settings().setAttribute(QWebEngineSettings.AllowRunningInsecureContent, True)
browser.settings().setAttribute(QWebEngineSettings.AllowWindowActivationFromJavaScript, True)
return browser
def init_profile(self, browser):
profile = QWebEngineProfile(browser)
profile.setHttpUserAgent('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.157 Safari/537.36')
return profile
def init_navbar(self):
navigation_bar = QToolBar('Navigation')
self.addToolBar(navigation_bar)
wa_button = QAction('whatsapp', self)
wa_url = 'https://web.whatsapp.com'
wa_button.triggered.connect(lambda: self.open_service(wa_url))
navigation_bar.addAction(wa_button)
slack_button = QAction('slack', self)
sl_url = 'https://www.slack.com'
slack_button.triggered.connect(lambda: self.open_service(sl_url))
navigation_bar.addAction(slack_button)
skype_button = QAction('skype', self)
sk_url = 'https://www.skype.com'
skype_button.triggered.connect(lambda: self.open_service(sk_url))
navigation_bar.addAction(skype_button)
quit_button = QAction('quit', self)
quit_button.triggered.connect(self.close_app)
navigation_bar.addAction(quit_button)
def open_service(self, surl):
self.webpage.load(QUrl(surl))
def close_app(self):
sys.exit()
async def load_p_url_co(page: QtWebEngineWidgets.QWebEnginePage, u: Qt.QUrl):
fut = asyncio.get_event_loop().create_future()
def ready(ok: bool):
su = page.url()
if su == u:
page.loadFinished.disconnect()
asyncio.get_event_loop().call_soon_threadsafe(fut.set_result, ok)
# else we have about:blank or something like it, let it run more times
page.loadFinished.connect(ready)
page.load(u)
return await fut
class MapWidget(QWebEngineView):
"""
The MapWidget class is a QWebEngineView that houses the leaflet map.
Since it is a QWidget, it can be added to any QLayout.
"""
@property
def page(self):
return self._page
@property
def channel(self):
return self._channel
def __init__(self, use_file_absolute_path: bool = True, alternative_base_path: str=""):
super().__init__()
if use_file_absolute_path or len(alternative_base_path) == 0:
self.base_path = os.path.dirname(os.path.abspath(__file__))
else:
self.base_path = alternative_base_path
self._page = QWebEnginePage()
self.setPage(self._page)
self._channel = QWebChannel()
self._page.setWebChannel(self._channel)
self._loadPage()
self.setContextMenuPolicy(Qt.NoContextMenu)
def _get_page_path(self):
return os.path.join(self.base_path, 'web', 'map.html')
def _loadPage(self):
html_path = self._get_page_path()
# QEventLoop is used to make the page loading behave syncronously
init_loop = QEventLoop()
self._page.loadFinished.connect(init_loop.quit)
self._page.load(QUrl().fromLocalFile(html_path))
init_loop.exec()
class ExtractorHtml:
def __init__(self, url):
_app = QApplication([])
self._page = QWebEnginePage()
self.html = None
# Небольшой костыль для получения содержимого страницы сайта
# https://www.origin.com/rus/ru-ru/search?searchString=
# Загрузка страницы проходит постепенно -- данные не сразу появляются, поэтому нужно
# подождать пока они закончатся загружаться. Для этого заводится таймер, который дает по 5 секунд
# после каждой закончившееся загрузки чтобы после вытащить данные из страницы
timer = QTimer()
timer.setSingleShot(True)
timer.setInterval(5000)
timer.timeout.connect(self._load_finished_handler)
self._page.loadProgress.connect(
lambda x: x == 100 and timer.start())
self._page.load(QUrl(url))
# Ожидание загрузки страницы и получения его содержимого
# Этот цикл асинхронный код делает синхронным
while self.html is None:
_app.processEvents()
_app.quit()
self._page = None
def _callable(self, data):
self.html = data
def _load_finished_handler(self):
self._page.toHtml(self._callable)
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.runner = Runner(self)
self.dc = DataCollector()
# self.comboBox.addItem("키워드")
# self.comboBox.addItem("주소")
self.itemList = []
self.rowList = []
# self.page.featurePermissionRequested.connect(self.setPagePermission)
#page 변환
self.pushButton_3.clicked.connect(self.translate_ui)
self.pushButton.clicked.connect(self.runner.map_removeMarkers)
# self.pushButton.clicked.connect(self.map_removeMarkers)
# self.pushButton.clicked.connect(self.runner.map_getLevel)
# self.pushButton.clicked.connect(lambda: self.runner.map_setLevel(random.randrange(7)))
# self.pushButton.clicked.connect(lambda: self.runner.coord_to_address(self.my_location_lat,self.my_location_lng, random.randrange(0,5)))
# self.pushButton.clicked.connect(lambda: self.getDistance([33.450500,126.569968],[[33.450500,126.569968],[35.404195,126.886323],[39.668777,126.065913]]))
# self.pushButton.clicked.connect(self.test_a)
# self.pushButton.clicked.connect(self.search)
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 translate_ui(self) :
print('aaaaaaaa')
self.stackedWidget.setCurrentIndex(1)
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))
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)
# self.runner.map_setLevel(2)
pass
@pyqtSlot(str)
def callme(self, arg: str):
# b = a.toObject()
print(arg)
js_call = jscall()
channel = QWebChannel(Page)
channel.registerObject("webobj", js_call)
Page.setWebChannel(channel)
def _status(status):
print('load status: ', status)
# Page.runJavaScript('window.d487 = document.getElementsByTagName("img")', _js)
# Page.runJavaScript('d487[1].src',_js)
# Page.runJavaScript('Qt.ev("document.getElementsByTagName(\'a\')")[1].click()', _js)
Page.runJavaScript('Qt.register()', _js)
def _js(result):
print('js result: ', result)
Page.loadFinished.connect(_status)
Page.load(QUrl.fromLocalFile(QDir.currentPath()+'/index.html'))
view.show()
app.exec()
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();")
import re
match = re.search(r'\d{,2}.\d{,2}.\d{4}', update_date_text)
if match is None:
return
date_string = match.group()
import os
file_name = os.path.basename(href)
file_name = date_string + '_' + file_name
from datetime import datetime
print(datetime.today().date(), file_name, file_url)
url = 'http://www.dns-shop.ru/'
app = QApplication([])
page = QWebEnginePage()
page.load(QUrl(url))
page.loadFinished.connect(lambda x=None: page.toHtml(_callable))
# Настроим вызов загрузки страницы на каждые 10 часов
timer = QTimer()
timer.setInterval(10 * 60 * 60 * 1000)
timer.timeout.connect(lambda x=None: page.load(QUrl(url)))
timer.start()
app.exec()
def load(self, url):
if not isinstance(url, QUrl):
url = QUrl.fromUserInput(url)
self.__delay_loading_url = None
return QWebEnginePage.load(self, url)
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 = "http://localhost:8080/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(
"http://localhost:8080/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)
print('result is: ', result)
def t(a):
print('status: ', a)
# viewPage.runJavaScript('var img=document.querySelector(".captcha_render");var canvas=document.createElement("canvas");canvas.width=img.width;canvas.height=img.height;var ctx=canvas.getContext("2d");ctx.drawImage(img,0,0);var dataURL=canvas.toDataURL("image/png");dataURL;',p)
# viewPage.runJavaScript('window.a1a = "omid";',p)
# viewPage.runJavaScript('"hi "+a1a;',stat)
# viewPage.printToPdf('nic.pdf')
# viewPage.printToPdf('t11111111111.pdf')
# size = viewPage.contentsSize().toSize()
# image = QImage(size, QImage.Format_ARGB32)
# region = QRegion(0,0,size.width(), size.height())
# painter = QPainter(image)
# viewPage.view().render(painter, QPoint(), region)
# painter.end()
# image.save("test.png", "PNG", 80)
print('saved!')
Page.loadFinished.connect(t)
Page.load(QUrl('https://google.com/'))
# image = QImage(page.contentsSize(),QImage.Format_ARGB32)
# painter = QPainter(image)
# page.ren
app.exec()
