def __init__(self, parent=None):
"""
Constructor
"""
QDialog.__init__(self, parent)
self.setupUi(self)
self.set_help_web_view()
self.help_file = None
# Connect
# noinspection PyUnresolvedReferences
self.pushButton_homeHelp.clicked.connect(self.get_root_help)
# noinspection PyUnresolvedReferences
self.pushButton_OAPI_timestamp.clicked.connect(
self.get_timestamp_overpass_api)
# noinspection PyUnresolvedReferences
self.comboBox_default_OAPI.currentIndexChanged[int].connect(
self.set_server_overpass_api)
self.query.signal_new_query_successful.connect(
self.signal_new_query_successful.emit)
self.my_queries.signal_delete_query_successful.connect(
self.signal_delete_query_successful.emit)
# noinspection PyUnresolvedReferences
self.pushButton_restoreQueries.clicked.connect(
self.restore_default_queries)
# noinspection PyUnresolvedReferences
self.radioButton_outputJson.toggled.connect(self.set_output_format)
# Set settings about the overpass API
self.defaultServer = get_setting('defaultOAPI')
if self.defaultServer:
index = self.comboBox_default_OAPI.findText(self.defaultServer)
self.comboBox_default_OAPI.setCurrentIndex(index)
else:
self.defaultServer = self.comboBox_default_OAPI.currentText()
set_setting('defaultOAPI', self.defaultServer)
# Set settings about the output
self.outputFormat = get_setting('outputFormat')
if self.outputFormat == "geojson":
self.radioButton_outputJson.setChecked(True)
elif self.outputFormat == "shape":
self.radioButton_outputShape.setChecked(True)
elif self.outputFormat == "spatialite":
self.radioButton_outputSpatialite.setChecked(True)
else:
set_setting('outputFormat', 'shape')
self.radioButton_outputShape.setChecked(True)
# Set minimum width for the menu
self.listWidget.setMinimumWidth(
self.listWidget.sizeHintForColumn(0) + 10)
def setup_panel(self):
"""Set UI related the configuration panel."""
self.dialog.save_config_overpass.clicked.connect(
self.set_server_overpass_api)
self.dialog.save_config_nominatim.clicked.connect(
self.set_server_nominatim_api)
for server in OVERPASS_SERVERS:
self.dialog.combo_default_overpass.addItem(server)
for server in NOMINATIM_SERVERS:
self.dialog.combo_default_nominatim.addItem(server)
# Read the config file
custom_config = custom_config_file()
if custom_config:
with open(custom_config, encoding='utf8') as file:
config_json = load(file)
for server in config_json.get('overpass_servers', []):
if server not in OVERPASS_SERVERS:
LOGGER.info(
'Custom overpass server list added: {}'.format(
server))
self.dialog.combo_default_overpass.addItem(server)
for server in config_json.get('nominatim_servers', []):
if server not in NOMINATIM_SERVERS:
LOGGER.info(
'Custom nominatim server list added: {}'.format(
server))
self.dialog.combo_default_nominatim.addItem(server)
# Set settings about the overpass API
# Set it after populating the combobox #235
default_server = get_setting('defaultOAPI')
if default_server:
index = self.dialog.combo_default_overpass.findText(default_server)
self.dialog.combo_default_overpass.setCurrentIndex(index)
else:
default_server = self.dialog.combo_default_overpass.currentText()
set_setting('defaultOAPI', default_server)
# Set settings about the nominatim APIs
# Set it after populating the combobox #235
default_server = get_setting('defaultNominatimAPI')
if default_server:
index = self.dialog.combo_default_nominatim.findText(
default_server)
self.dialog.combo_default_nominatim.setCurrentIndex(index)
else:
default_server = self.dialog.combo_default_nominatim.currentText()
set_setting('defaultNominatimAPI', default_server)
def __init__(self, parent=None):
"""
Constructor
"""
QDialog.__init__(self, parent)
self.setupUi(self)
self.set_help_web_view()
self.help_file = None
# Connect
# noinspection PyUnresolvedReferences
self.pushButton_homeHelp.clicked.connect(self.get_root_help)
# noinspection PyUnresolvedReferences
self.pushButton_OAPI_timestamp.clicked.connect(
self.get_timestamp_overpass_api)
# noinspection PyUnresolvedReferences
self.comboBox_default_OAPI.currentIndexChanged[int].connect(
self.set_server_overpass_api)
self.query.signal_new_query_successful.connect(
self.signal_new_query_successful.emit)
self.my_queries.signal_delete_query_successful.connect(
self.signal_delete_query_successful.emit)
# noinspection PyUnresolvedReferences
self.pushButton_restoreQueries.clicked.connect(
self.restore_default_queries)
# noinspection PyUnresolvedReferences
self.radioButton_outputJson.toggled.connect(self.set_output_format)
# Set settings about the overpass API
self.defaultServer = get_setting('defaultOAPI')
if self.defaultServer:
index = self.comboBox_default_OAPI.findText(self.defaultServer)
self.comboBox_default_OAPI.setCurrentIndex(index)
else:
self.defaultServer = self.comboBox_default_OAPI.currentText()
set_setting('defaultOAPI', self.defaultServer)
# Set settings about the output
self.outputFormat = get_setting('outputFormat')
if self.outputFormat == "geojson":
self.radioButton_outputJson.setChecked(True)
elif self.outputFormat == "shape":
self.radioButton_outputShape.setChecked(True)
else:
set_setting('outputFormat', 'shape')
self.radioButton_outputShape.setChecked(True)
# Set minimum width for the menu
self.listWidget.setMinimumWidth(
self.listWidget.sizeHintForColumn(0) + 10)
def __init__(self,
query,
extent=None,
area=None,
overpass=None,
output_format='xml'):
"""Constructor.
:param query: The query to prepare.
:type query: str
:param extent: The extent to use in 4326, if needed. It can be None.
:type extent: QgsRectangle
:param area: A name or a list of place names.
:type area: str, list(str)
"""
if overpass is None:
server = get_setting('defaultOAPI',
OVERPASS_SERVERS[0]) + 'interpreter'
self._overpass = QUrl(server + 'interpreter')
else:
self._overpass = QUrl(overpass)
self._query = query
self._query_prepared = query
self._extent = extent
self._places = area
self._output_format = output_format
self._nominatim = None
self._query_is_ready = False
def process_query(dialog=None,
query=None,
nominatim=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, nominatim)
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI')
dialog.set_progress_text(tr('Downloading data from Overpass'))
QApplication.processEvents()
connexion_overpass_api = ConnexionOAPI(url=server, output="xml")
osm_file = connexion_overpass_api.query(query.prepare_query())
return open_file(dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_dir=output_dir,
prefix_file=prefix_file,
config_outputs=config_outputs)
def __init__(
self, query, extent=None, nominatim_place=None,
overpass=None, output_format='xml'):
"""Constructor.
:param query: The query to prepare.
:type query: str
:param extent: The extent to use in 4326, if needed. It can be None.
:type extent: QgsRectangle
:param nominatim_place: A name or a list of place names.
:type nominatim_place: str, list(str)
"""
if overpass is None:
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
self._overpass = QUrl(server + 'interpreter')
else:
self._overpass = QUrl(overpass)
self._query = query
self._query_prepared = query
self._extent = extent
self._nominatim_places = nominatim_place
self._output_format = output_format
self._query_is_ready = False
def replace(catch, default_nominatim):
if default_nominatim:
search = default_nominatim
else:
search = catch
# if the result is already a number, it's a relation ID.
# we don't perform a nominatim query
if search.isdigit():
osm_id = search
else:
# We perform a nominatim query
if not self._nominatim:
server = get_setting('defaultNominatimAPI',
NOMINATIM_SERVERS[0])
self._nominatim = Nominatim(server)
osm_id = self._nominatim.get_first_polygon_from_query(search)
# HACK when running in test.
# In production, osm_id IS an integer, not in tests.
if osm_id == 'foo_BAR':
osm_id = 12345
elif osm_id == 'bar_FOO':
osm_id = 54321
# END big hack
area = int(osm_id) + 3600000000
if self.is_oql_query():
new_string = 'area({})'.format(area)
else:
new_string = 'ref="{}" type="area"'.format(area)
return new_string
def replace(catch, default_nominatim):
if default_nominatim:
search = default_nominatim
else:
search = catch
lat = None
lon = None
# Try first if it's a point written in WKT
geom = QgsGeometry.fromWkt(search)
if geom.isGeosValid():
try:
point = geom.asPoint()
lon = point.x()
lat = point.y()
LOGGER.info(tr('WKT detected for "geocodeCoords".'))
except TypeError:
pass
if lat is None and lon is None:
if not self._nominatim:
server = get_setting('defaultNominatimAPI',
NOMINATIM_SERVERS[0])
self._nominatim = Nominatim(server)
lon, lat = self._nominatim.get_first_point_from_query(search)
if self.is_oql_query():
new_string = '{},{}'.format(lat, lon)
else:
new_string = 'lat="{}" lon="{}"'.format(lat, lon)
return new_string
def add_bottom_parameters(self):
parameter = QgsProcessingParameterNumber(
self.TIMEOUT, tr('Timeout'), defaultValue=25, minValue=5)
parameter.setFlags(
parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
server = get_setting(
'defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
parameter = QgsProcessingParameterString(
self.SERVER,
tr('Overpass server'),
optional=False,
defaultValue=server)
parameter.setFlags(
parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_URL, tr('Query as encoded URL')))
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_OQL_QUERY, tr('Raw query as OQL')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterString(
self.QUERY, tr('Query'), optional=False, multiLine=True))
self.addParameter(
QgsProcessingParameterExtent(
self.EXTENT, tr('Extent, if "{{bbox}}" in the query'), optional=True))
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
parameter = QgsProcessingParameterString(
self.SERVER, tr('Overpass server'), optional=False, defaultValue=server)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterString(
self.AREA,
tr('Area (if you want to override {{geocodeArea}} in the query'),
optional=True)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_URL, tr('Query as encoded URL')))
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_OQL_QUERY, tr('Raw query as OQL')))
def open_copyright_message(dialog: QDialog):
"""Display a window to bring a reminder of the OSM copyrights."""
def read_copyright():
open_webpage('https://www.openstreetmap.org/copyright')
set_setting("copyright_dialog", "OpenStreetMap")
def know_copyright():
set_setting("copyright_dialog", "OpenStreetMap")
if not get_setting("copyright_dialog"):
message = QMessageBox(dialog)
text = tr(
'OpenStreetMap® is open data, licensed under the'
' Open Data Commons Open Database License (ODbL) '
'by the OpenStreetMap Foundation.'
) + '\n'
text += tr(
'The Foundation requires that you use the credit '
'“© OpenStreetMap contributors” on any product using OSM data.'
) + '\n'
text += tr(
'You should read https://www.openstreetmap.org/copyright'
)
message.setText(text)
message.setIcon(QMessageBox.Question)
no_button = QPushButton(tr('I understand the copyrights, access to the plugin'), message)
yes_button = QPushButton(tr('I want to read the copyrights'), message)
message.addButton(no_button, QMessageBox.NoRole)
message.addButton(yes_button, QMessageBox.YesRole)
yes_button.clicked.connect(read_copyright)
no_button.clicked.connect(know_copyright)
message.exec()
def set_ui_configuration_panel(self):
"""Set UI related the configuration panel."""
self._set_custom_ui(Panels.QuickQuery)
# noinspection PyUnresolvedReferences
self.combo_default_overpass.currentIndexChanged.connect(
self.set_server_overpass_api)
# Set settings about the overpass API
self.default_server = get_setting('defaultOAPI')
if self.default_server:
index = self.combo_default_overpass.findText(self.default_server)
self.combo_default_overpass.setCurrentIndex(index)
else:
self.default_server = self.combo_default_overpass.currentText()
set_setting('defaultOAPI', self.default_server)
for server in OVERPASS_SERVERS:
self.combo_default_overpass.addItem(server)
# Read the config file
custom_config = custom_config_file()
if custom_config:
with open(custom_config) as f:
config_json = load(f)
for server in config_json.get('overpass_servers'):
if server not in OVERPASS_SERVERS:
LOGGER.info(
'Custom overpass server list added: {}'.format(
server))
self.combo_default_overpass.addItem(server)
def process_query(
dialog=None,
query=None,
nominatim=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Check OGR
if not is_ogr_version_ok():
raise GDALVersion
if not is_osm_driver_enabled():
raise OsmDriverNotFound
# Get output's format
output_format = get_setting('outputFormat')
# Prepare outputs
dialog.set_progress_text(tr("QuickOSM", u"Prepare outputs"))
# Replace Nominatim or BBOX
query = prepare_query(query=query, nominatim_name=nominatim, extent=bbox)
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI')
dialog.set_progress_text(tr("QuickOSM", u"Downloading data from Overpass"))
QApplication.processEvents()
connexion_overpass_api = ConnexionOAPI(url=server, output="xml")
osm_file = connexion_overpass_api.get_file_from_query(query)
return open_file(
dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_format=output_format,
output_dir=output_dir,
prefix_file=prefix_file,
config_outputs=config_outputs)
def process_query(
dialog=None,
query=None,
nominatim=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Check OGR
if not is_ogr_version_ok():
raise GDALVersion
if not is_osm_driver_enabled():
raise OsmDriverNotFound
# Get output's format
output_format = get_setting('outputFormat')
# Prepare outputs
dialog.set_progress_text(tr("QuickOSM", u"Prepare outputs"))
# Replace Nominatim or BBOX
query = prepare_query(query=query, nominatim_name=nominatim, extent=bbox)
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI')
dialog.set_progress_text(tr("QuickOSM", u"Downloading data from Overpass"))
QApplication.processEvents()
connexion_overpass_api = ConnexionOAPI(url=server, output="xml")
osm_file = connexion_overpass_api.get_file_from_query(query)
return open_file(
dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_format=output_format,
output_dir=output_dir,
prefix_file=prefix_file,
config_outputs=config_outputs)
def add_bottom_parameters(self):
param = QgsProcessingParameterNumber(self.TIMEOUT,
tr('Timeout'),
defaultValue=25,
minValue=5)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
help_string = tr('The timeout to use for the Overpass API.')
if Qgis.QGIS_VERSION_INT >= 31500:
param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addParameter(param)
server = get_setting('defaultOAPI',
OVERPASS_SERVERS[0]) + 'interpreter'
param = QgsProcessingParameterString(self.SERVER,
tr('Overpass server'),
optional=False,
defaultValue=server)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
help_string = tr(
'The Overpass API server to use to build the encoded URL.')
if Qgis.QGIS_VERSION_INT >= 31500:
param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addParameter(param)
output = QgsProcessingOutputString(self.OUTPUT_URL,
tr('Query as encoded URL'))
help_string = tr(
'The query is generated and encoded with the Overpass API URL. This output should be used in the '
'File Downloader algorithm.')
if Qgis.QGIS_VERSION_INT >= 31500:
pass
# output.setHelp(help_string)
else:
output.tooltip_3liz = help_string
self.addOutput(output)
output = QgsProcessingOutputString(self.OUTPUT_OQL_QUERY,
tr('Raw query as OQL'))
help_string = tr('The query is generated in the OQL format.')
if Qgis.QGIS_VERSION_INT >= 31500:
pass
# output.setHelp(help_string)
else:
output.tooltip_3liz = help_string
self.addOutput(output)
def __init__(self, parent=None):
"""
Constructor
"""
QDialog.__init__(self, parent)
self.setupUi(self)
# Set icons
item = self.listWidget.item(0)
item.setIcon(QIcon(resources_path('quick.png')))
item = self.listWidget.item(1)
item.setIcon(QIcon(resources_path('edit.png')))
item = self.listWidget.item(2)
item.setIcon(QIcon(resources_path('open.png')))
item = self.listWidget.item(3)
item.setIcon(QIcon(resources_path('general.svg')))
item = self.listWidget.item(4)
item.setIcon(QIcon(resources_path('info.png')))
self.label_gnu.setPixmap(QPixmap(resources_path('gnu.png')))
# Disabled in QGIS3
# self.set_help_web_view()
self.restore_queries_group.setVisible(False)
self.timestamp_group.setVisible(False)
self.help_file = None
# Connect
# noinspection PyUnresolvedReferences
# self.pushButton_homeHelp.clicked.connect(self.get_root_help) QGIS 3
# noinspection PyUnresolvedReferences
# self.pushButton_OAPI_timestamp.clicked.connect(
# self.get_timestamp_overpass_api)
# noinspection PyUnresolvedReferences
self.comboBox_default_OAPI.currentIndexChanged[int].connect(
self.set_server_overpass_api)
# Set settings about the overpass API
self.defaultServer = get_setting('defaultOAPI')
if self.defaultServer:
index = self.comboBox_default_OAPI.findText(self.defaultServer)
self.comboBox_default_OAPI.setCurrentIndex(index)
else:
self.defaultServer = self.comboBox_default_OAPI.currentText()
set_setting('defaultOAPI', self.defaultServer)
# Set minimum width for the menu
self.listWidget.setMinimumWidth(
self.listWidget.sizeHintForColumn(0) + 10)
def add_bottom_parameters(self):
"""Set up the advanced parameters."""
param = QgsProcessingParameterNumber(
self.TIMEOUT, tr('Timeout'), defaultValue=25, minValue=5)
param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
help_string = tr('The timeout to use for the Overpass API.')
param.setHelp(help_string)
self.addParameter(param)
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
param = QgsProcessingParameterString(
self.SERVER,
tr('Overpass server'),
optional=False,
defaultValue=server)
param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
help_string = tr('The Overpass API server to use to build the encoded URL.')
param.setHelp(help_string)
self.addParameter(param)
def add_bottom_parameters(self):
parameter = QgsProcessingParameterNumber(
self.TIMEOUT, tr('Timeout'), defaultValue=25, minValue=5)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
parameter = QgsProcessingParameterString(
self.SERVER, tr('Overpass server'), optional=False, defaultValue=server)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_URL, tr('Query as encoded URL')))
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_OQL_QUERY, tr('Raw query as OQL')))
def generate_query(self, oql_output: bool = True):
"""Generate the query as final."""
query = self.dialog.text_query.toPlainText()
area = self.dialog.places_edits[Panels.Query].text()
self.write_nominatim_file(Panels.Query)
properties = self.gather_values()
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'convert'
query = QueryPreparation(query, properties['bbox'], area, server)
query_string = query.prepare_query()
if (oql_output
and not query.is_oql_query()) or (not oql_output
and query.is_oql_query()):
query.prepare_query()
url = query.prepare_url(
QueryLanguage.OQL if oql_output else QueryLanguage.XML)
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
query_string = connexion_overpass_api.run_convert()
query_string = html.unescape(query_string)
self.dialog.text_query.setPlainText(query_string)
def process_query(
dialog=None,
query=None,
area=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
dialog.set_progress_text(
tr('Downloading data from Overpass {server_name}'.format(
server_name=server)))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, area, server)
QApplication.processEvents()
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
return open_file(
dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_dir=output_dir,
prefix_file=prefix_file,
final_query=final_query,
config_outputs=config_outputs)
def process_query(
dialog=None,
query=None,
nominatim=None,
bbox=None,
output_dir=None,
prefix_file=None,
output_geometry_types=None,
layer_name="OsmQuery",
white_list_values=None,
config_outputs=None):
"""execute a query and send the result file to open_file."""
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
dialog.set_progress_text(
tr('Downloading data from Overpass {}').format(server))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, nominatim, server)
QApplication.processEvents()
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
return open_file(
dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
layer_name=layer_name,
output_dir=output_dir,
prefix_file=prefix_file,
final_query=final_query,
config_outputs=config_outputs)
def reload_query(query: str,
layer_name: str = 'Reloaded_query',
dialog: QDialog = None,
new_file: bool = True):
""" Reload a query with only the query """
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
query = QueryPreparation(query, overpass=server)
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
if new_file:
layer_name += "_reloaded"
return open_file(
dialog=dialog,
osm_file=osm_file,
layer_name=layer_name,
final_query=final_query,
)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterString(
self.QUERY, tr('Query'), optional=False, multiLine=True))
self.addParameter(
QgsProcessingParameterExtent(
self.EXTENT,
tr('Extent, if "{{bbox}}" in the query'),
optional=True))
server = get_setting(
'defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
parameter = QgsProcessingParameterString(
self.SERVER,
tr('Overpass server'),
optional=False,
defaultValue=server)
parameter.setFlags(
parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterString(
self.AREA,
tr('Area (if you want to override {{geocodeArea}} in the query)'),
optional=True)
parameter.setFlags(
parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_URL, tr('Query as encoded URL')))
self.addOutput(
QgsProcessingOutputString(
self.OUTPUT_OQL_QUERY, tr('Raw query as OQL')))
def __init__(self, parent=None):
"""
Constructor
"""
QDialog.__init__(self, parent)
self.setupUi(self)
# Set icons
item = self.listWidget.item(0)
item.setIcon(QIcon(resources_path('quick.png')))
item = self.listWidget.item(1)
item.setIcon(QIcon(resources_path('edit.png')))
item = self.listWidget.item(2)
item.setIcon(QIcon(resources_path('open.png')))
item = self.listWidget.item(3)
item.setIcon(QIcon(resources_path('general.svg')))
item = self.listWidget.item(4)
item.setIcon(QIcon(resources_path('info.png')))
self.label_gnu.setPixmap(QPixmap(resources_path('gnu.png')))
# Disabled in QGIS3
# self.set_help_web_view()
self.restore_queries_group.setVisible(False)
self.timestamp_group.setVisible(False)
self.output_format_option.setVisible(False)
self.help_file = None
# Connect
# noinspection PyUnresolvedReferences
# self.pushButton_homeHelp.clicked.connect(self.get_root_help) QGIS 3
# noinspection PyUnresolvedReferences
# self.pushButton_OAPI_timestamp.clicked.connect(
# self.get_timestamp_overpass_api)
# noinspection PyUnresolvedReferences
self.comboBox_default_OAPI.currentIndexChanged[int].connect(
self.set_server_overpass_api)
self.query.signal_new_query_successful.connect(
self.signal_new_query_successful.emit)
# self.my_queries.signal_delete_query_successful.connect(
# self.signal_delete_query_successful.emit)
# noinspection PyUnresolvedReferences
self.pushButton_restoreQueries.clicked.connect(
self.restore_default_queries)
# noinspection PyUnresolvedReferences
self.radioButton_outputJson.toggled.connect(self.set_output_format)
# Set settings about the overpass API
self.defaultServer = get_setting('defaultOAPI')
if self.defaultServer:
index = self.comboBox_default_OAPI.findText(self.defaultServer)
self.comboBox_default_OAPI.setCurrentIndex(index)
else:
self.defaultServer = self.comboBox_default_OAPI.currentText()
set_setting('defaultOAPI', self.defaultServer)
# Set settings about the output
self.outputFormat = get_setting('outputFormat')
if self.outputFormat == "geojson":
self.radioButton_outputJson.setChecked(True)
elif self.outputFormat == "shape":
self.radioButton_outputShape.setChecked(True)
else:
set_setting('outputFormat', 'shape')
self.radioButton_outputShape.setChecked(True)
# Set minimum width for the menu
self.listWidget.setMinimumWidth(
self.listWidget.sizeHintForColumn(0) + 10)
def process_query(dialog: QDialog = None,
query: str = None,
description: str = None,
area: Union[str, List[str]] = None,
key: Union[str, List[str]] = None,
value: Union[str, List[str]] = None,
type_multi_request: list = None,
bbox: QgsRectangle = None,
output_dir: str = None,
output_format: Format = None,
prefix_file: str = None,
output_geometry_types: list = None,
layer_name: str = "OsmQuery",
white_list_values: dict = None,
config_outputs: dict = None) -> int:
"""execute a query and send the result file to open_file."""
# Save the query in the historic
q_manage = QueryManagement(query=query,
name=prefix_file if prefix_file else layer_name,
description=description,
advanced=value is None,
type_multi_request=type_multi_request,
keys=key,
values=value,
area=area,
bbox=bbox,
output_geometry_types=output_geometry_types,
white_list_column=white_list_values)
q_manage.write_query_historic()
if dialog.feedback_process.isCanceled():
return None
# Prepare outputs
dialog.set_progress_text(tr('Prepare outputs'))
# Getting the default overpass api and running the query
server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
dialog.set_progress_text(
tr('Downloading data from Overpass {server_name}'.format(
server_name=server)))
# Replace Nominatim or BBOX
query = QueryPreparation(query, bbox, area, server)
QApplication.processEvents()
final_query = query.prepare_query()
url = query.prepare_url()
connexion_overpass_api = ConnexionOAPI(url)
LOGGER.debug('Encoded URL: {}'.format(url))
osm_file = connexion_overpass_api.run()
return open_file(dialog=dialog,
osm_file=osm_file,
output_geom_types=output_geometry_types,
white_list_column=white_list_values,
key=key,
layer_name=layer_name,
output_dir=output_dir,
output_format=output_format,
prefix_file=prefix_file,
final_query=final_query,
config_outputs=config_outputs,
feedback=dialog.feedback_process)
def initGui(self):
# Setup menu
self.quickosm_menu = QMenu('Quick OSM')
self.quickosm_menu.setIcon(
QIcon(join(dirname(__file__), 'resources', 'QuickOSM.svg')))
self.dock_menu = QMenu(tr('QuickOSM', u'Dock'))
self.vector_menu = self.iface.vectorMenu()
self.vector_menu.addMenu(self.quickosm_menu)
# Main window
self.mainWindowAction = QAction(
QIcon(join(dirname(__file__), 'resources', 'QuickOSM.svg')),
u'QuickOSM', self.iface.mainWindow())
# noinspection PyUnresolvedReferences
self.mainWindowAction.triggered.connect(self.openMainWindow)
self.toolbar.addAction(self.mainWindowAction)
self.iface.QuickOSM_mainWindowDialog = MainWindowDialog()
self.josmAction = QAction(
QIcon(join(dirname(__file__), 'resources', 'josm_icon.svg')),
'JOSM Remote', self.iface.mainWindow())
self.josmAction.triggered.connect(self.josm_remote)
self.toolbar.addAction(self.josmAction)
# OSM File
# self.osmFileAction = QAction(
# QIcon(':/plugins/QuickOSM/resources/open.png'),
# tr('ui_osm_file', 'OSM File'),
# self.iface.mainWindow())
# # noinspection PyUnresolvedReferences
# self.osmFileAction.triggered.connect(self.openOsmFileDockWidget)
# self.osmFileDockWidget = OsmFileDockWidget()
# self.iface.addDockWidget(
# Qt.RightDockWidgetArea, self.osmFileDockWidget)
# self.osmFileDockWidget.hide()
# self.osmFileDockWidget.setObjectName('osmFileWidget')
# My queries
# self.myQueriesAction = QAction(
# QIcon(':/plugins/QuickOSM/resources/favorites.png'),
# tr('ui_my_queries', 'My queries'),
# self.iface.mainWindow())
# # noinspection PyUnresolvedReferences
# self.myQueriesAction.triggered.connect(self.openMyQueriesDockWidget)
# self.myQueriesDockWidget = MyQueriesDockWidget()
# self.iface.addDockWidget(
# Qt.RightDockWidgetArea, self.myQueriesDockWidget)
# self.myQueriesDockWidget.hide()
# self.myQueriesDockWidget.setObjectName('myQueriesWidget')
# Query
# self.queryAction = QAction(
# QIcon(':/plugins/QuickOSM/resources/edit.png'),
# tr('ui_query', 'Query'),
# self.iface.mainWindow())
# # noinspection PyUnresolvedReferences
# self.queryAction.triggered.connect(self.openQueryDockWidget)
# self.queryDockWidget = QueryDockWidget()
# self.iface.addDockWidget(Qt.RightDockWidgetArea, self.queryDockWidget)
# self.queryDockWidget.hide()
# self.queryDockWidget.setObjectName('queryWidget')
# Quick query
# self.quickQueryAction = QAction(
# QIcon(':/plugins/QuickOSM/resources/quick.png'),
# tr('ui_quick_query', 'Quick query'),
# self.iface.mainWindow())
# # noinspection PyUnresolvedReferences
# self.quickQueryAction.triggered.connect(self.openQuickQueryDockWidget)
# self.quickQueryDockWidget = QuickQueryDockWidget()
# self.iface.addDockWidget(
# Qt.RightDockWidgetArea, self.quickQueryDockWidget)
# self.quickQueryDockWidget.hide()
# self.quickQueryDockWidget.setObjectName('quickQueryWidget')
# Insert in the good order
self.quickosm_menu.addAction(self.mainWindowAction)
# self.quickosm_menu.addMenu(self.dock_menu)
# self.dock_menu.addAction(self.quickQueryAction)
# self.dock_menu.addAction(self.queryAction)
# self.dock_menu.addAction(self.myQueriesAction)
# self.dock_menu.addAction(self.osmFileAction)
# Connect signals and slots from dock
# self.queryDockWidget.signal_new_query_successful.connect(
# self.iface.QuickOSM_mainWindowDialog.refresh_my_queries_tree)
# self.queryDockWidget.signal_new_query_successful.connect(
# self.myQueriesDockWidget.refresh_my_queries_tree)
# self.myQueriesDockWidget.signal_delete_query_successful.connect(
# self.myQueriesDockWidget.refresh_my_queries_tree)
# self.myQueriesDockWidget.signal_delete_query_successful.connect(
# self.iface.QuickOSM_mainWindowDialog.refresh_my_queries_tree)
# Connect signals and slots from mainWindow
# self.iface.QuickOSM_mainWindowDialog.signal_new_query_successful.\
# connect(self.myQueriesDockWidget.refresh_my_queries_tree)
# self.iface.QuickOSM_mainWindowDialog.signal_new_query_successful.\
# connect(
# self.iface.QuickOSM_mainWindowDialog.refresh_my_queries_tree)
# self.iface.QuickOSM_mainWindowDialog.signal_delete_query_successful.\
# connect(self.myQueriesDockWidget.refresh_my_queries_tree)
# self.iface.QuickOSM_mainWindowDialog.signal_delete_query_successful.\
# connect(
# self.iface.QuickOSM_mainWindowDialog.refresh_my_queries_tree)
# Read the config file
json_file_config = join(dirname(abspath(__file__)), 'config.json')
if isfile(json_file_config):
with open(json_file_config) as f:
config_json = load(f)
for server in config_json['overpass_servers']:
self.iface.QuickOSM_mainWindowDialog.comboBox_default_OAPI.\
addItem(server)
# Check previous version and if new queries are available
version = get_setting('version')
current_version = get_current_version()
if version != current_version:
if new_queries_available():
message = 'New queries are available in the plugin. Would ' \
'like to install them ? This will overwrite the ' \
'current default queries.'
title = 'QuickOSM'
message = tr('QuickOSM', message)
widget = self.iface.messageBar().createMessage(title, message)
button_ok = QPushButton(widget)
button_ok.setText(tr('QuickOSM', 'Install'))
button_ok.pressed.connect(self.restoreDefaultQueries)
widget.layout().addWidget(button_ok)
self.iface.messageBar().pushWidget(widget, Qgis.Info, 0)
set_setting('version', current_version)
def initAlgorithm(self, config=None):
param = QgsProcessingParameterString(self.QUERY,
tr('Query'),
optional=False,
multiLine=True)
help_string = tr(
'A XML or OQL query to be send to the Overpass API. It can contains some {{}} tokens.'
)
if Qgis.QGIS_VERSION_INT >= 31500:
param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addParameter(param)
param = QgsProcessingParameterExtent(
self.EXTENT,
tr('Extent, if "{{bbox}}" in the query'),
optional=True)
help_string = tr(
'If the query has a {{bbox}} token, this extent will be used for replacement.'
)
if Qgis.QGIS_VERSION_INT >= 31500:
param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addParameter(param)
server = get_setting('defaultOAPI',
OVERPASS_SERVERS[0]) + 'interpreter'
param = QgsProcessingParameterString(self.SERVER,
tr('Overpass server'),
optional=False,
defaultValue=server)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
help_string = tr(
'The Overpass API server to use to build the encoded URL.')
if Qgis.QGIS_VERSION_INT >= 31500:
param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addParameter(param)
param = QgsProcessingParameterString(
self.AREA,
tr('Area (if you want to override {{geocodeArea}} in the query)'),
optional=True)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
help_string = tr('{{geocodeArea}} can be overridden on runtime.')
if Qgis.QGIS_VERSION_INT >= 31500:
param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addParameter(param)
output = QgsProcessingOutputString(self.OUTPUT_URL,
tr('Query as encoded URL'))
help_string = tr(
'The query is generated and encoded with the Overpass API URL. This output should be used in the '
'File Downloader algorithm.')
if Qgis.QGIS_VERSION_INT >= 31500:
pass
# param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addOutput(output)
output = QgsProcessingOutputString(self.OUTPUT_OQL_QUERY,
tr('Raw query as OQL'))
help_string = tr('The query is generated in the OQL format.')
if Qgis.QGIS_VERSION_INT >= 31500:
pass
# param.setHelp(help_string)
else:
param.tooltip_3liz = help_string
self.addOutput(output)
def initGui(self):
# Setup menu
self.quickosm_menu = QMenu('QuickOSM')
self.quickosm_menu.setIcon(
QIcon(join(dirname(__file__), 'resources', 'QuickOSM.svg')))
self.vector_menu = self.iface.vectorMenu()
self.vector_menu.addMenu(self.quickosm_menu)
# Main window
self.mainWindowAction = QAction(
QIcon(join(dirname(__file__), 'resources', 'QuickOSM.svg')),
u'QuickOSM', self.iface.mainWindow())
# noinspection PyUnresolvedReferences
self.mainWindowAction.triggered.connect(self.openMainWindow)
self.toolbar.addAction(self.mainWindowAction)
self.iface.QuickOSM_mainWindowDialog = MainWindowDialog()
# Action JOSM
self.josmAction = QAction(
QIcon(join(dirname(__file__), 'resources', 'josm_icon.svg')),
'JOSM Remote', self.iface.mainWindow())
self.josmAction.triggered.connect(self.josm_remote)
self.toolbar.addAction(self.josmAction)
# Insert in the good order
self.quickosm_menu.addAction(self.mainWindowAction)
self.quickosm_menu.addAction(self.josmAction)
for server in OVERPASS_SERVERS:
self.iface.QuickOSM_mainWindowDialog.comboBox_default_OAPI. \
addItem(server)
# Read the config file
custom_config = join(quickosm_user_folder(), 'custom_config.json')
if isfile(custom_config):
with open(custom_config) as f:
config_json = load(f)
for server in config_json.get('overpass_servers'):
if server not in OVERPASS_SERVERS:
LOGGER.info(
'Custom overpass server list added: {}'.format(
server))
self.iface.QuickOSM_mainWindowDialog.\
comboBox_default_OAPI.addItem(server)
# Check previous version and if new queries are available
version = get_setting('version')
current_version = get_current_version()
if version != current_version:
if new_queries_available():
widget = self.iface.messageBar().createMessage(
'QuickOSM',
tr('New queries are available in the plugin. Would like '
'to install them ? This will overwrite the current '
'default queries.'))
button_ok = QPushButton(widget)
button_ok.setText(tr('Install'))
button_ok.pressed.connect(self.restoreDefaultQueries)
widget.layout().addWidget(button_ok)
self.iface.messageBar().pushWidget(widget, Qgis.Info, 0)
set_setting('version', current_version)
